name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
Buffer_change_event_add_hton_u8_Test::~Buffer_change_event_add_hton_u8_Test() | TEST(Buffer, change_event_add_hton_u8) {
BufferWithReadonlyStrings local;
auto constexpr addme = uint8_t { 128 };
auto constexpr size = sizeof(addme);
auto const expected = bfy_changed_cb_info {
.orig_size = bfy_buffer_get_content_len(&local.buf),
.n_added = size,
.n_deleted = 0
};
local.start_listening_to_changes();
EXPECT_EQ(0, bfy_buffer_add_hton_u8(&local.buf, addme));
EXPECT_EQ(changes_t{expected}, local.changes);
} | pushq %rbx
movq %rdi, %rbx
callq 0x3c17a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x10490
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_change_event_add_hton_u32_Test::~Buffer_change_event_add_hton_u32_Test() | TEST(Buffer, change_event_add_hton_u32) {
BufferWithReadonlyStrings local;
auto constexpr addme = uint32_t { 128 };
auto constexpr size = sizeof(addme);
auto const expected = bfy_changed_cb_info {
.orig_size = bfy_buffer_get_content_len(&local.buf),
.n_added = size,
.n_deleted = 0
};
local.start_listening_to_changes();
EXPECT_EQ(0, bfy_buffer_add_hton_u32(&local.buf, addme));
EXPECT_EQ(changes_t{expected}, local.changes);
} | pushq %rbx
movq %rdi, %rbx
callq 0x3c17a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x10490
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_change_event_add_printf_Test::~Buffer_change_event_add_printf_Test() | TEST(Buffer, change_event_add_printf) {
BufferWithReadonlyStrings local;
auto constexpr str = std::string_view { "Lorem ipsum dolor sit amet" };
auto constexpr size = std::size(str);
auto const expected = bfy_changed_cb_info {
.orig_size = bfy_buffer_get_content_len(&local.buf),
.n_added = size,
.n_deleted = 0
};
local.start_listening_to_changes();
EXPECT_EQ(0, bfy_buffer_add_printf(&local.buf, "%s", std::data(str)));
EXPECT_EQ(changes_t{expected}, local.changes);
} | pushq %rbx
movq %rdi, %rbx
callq 0x3c17a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x10490
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
testing::AssertionResult testing::internal::CmpHelperOpFailure<char const*, void const*>(char const*, char const*, char const* const&, void const* const&, char const*) | AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
const T1& val1, const T2& val2,
const char* op) {
return AssertionFailure()
<< "Expected: (" << expr1 << ") " << op << " (" << expr2
<< "), actual: " << FormatForComparisonFailureMessage(val1, val2)
<< " vs " << FormatForComparisonFailureMessage(val2, val1);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq %rsp, %r12
movq %r12, %rdi
callq 0x382ba
leaq 0x3510b(%rip), %rsi # 0x635e6
movq %r12, %rdi
callq 0x2e650
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x350fb(%rip), %rsi # 0x635f2
movq %rax, %rdi
callq 0x2e75e
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x350dc(%rip), %rsi # 0x635ef
movq %rax, %rdi
callq 0x2e75e
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x350c6(%rip), %rsi # 0x635f5
movq %rax, %rdi
callq 0x2e650
movq %rax, %r12
movq (%r15), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x48(%rsp), %rdi
callq 0x2eb4c
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x2e7dc
leaq 0x3509e(%rip), %rsi # 0x63601
movq %rax, %rdi
callq 0x2e850
movq %rax, %r15
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x2eb4c
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x2e7dc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x381d8
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e5ae
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e5c9
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x2e5dd
leaq 0x8(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2e610
jmp 0x2e630
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e613
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x2e613
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e633
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x2e633
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x2e647
leaq 0x8(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char const*>(char const* const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x37e78
movq (%r14), %r15
movq (%r12), %r14
addq $0x10, %r14
testq %r15, %r15
je 0x2e704
movq %r15, %rdi
callq 0x101b0
movq %rax, %rdx
jmp 0x2e710
movl $0x6, %edx
leaq 0x34f0b(%rip), %r15 # 0x6361b
movq %r14, %rdi
movq %r15, %rsi
callq 0x10560
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2e8ce
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2e735
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2e756
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
void testing::internal::PointerPrinter::PrintValue<bfy_buffer>(bfy_buffer*, std::ostream*) | static void PrintValue(T* p, ::std::ostream* os) {
if (p == nullptr) {
*os << "NULL";
} else {
// T is not a function type. We just call << to print p,
// relying on ADL to pick up user-defined << for their pointer
// types, if any.
*os << p;
}
} | movq %rsi, %rcx
testq %rdi, %rdi
je 0x30ce0
movq %rdi, %rax
movq %rcx, %rdi
movq %rax, %rsi
jmp 0x10380
leaq 0x3293b(%rip), %rsi # 0x63622
movl $0x4, %edx
movq %rcx, %rdi
jmp 0x10560
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest-printers.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<unsigned long, unsigned long>(char const*, char const*, unsigned long const&, unsigned long const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x30997
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x30997
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x3906e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30d7e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30d99
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30dcb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x30dcb
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30de6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<int, int>(char const*, char const*, int const&, int const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x30914
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x30914
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x3906e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30e77
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30e92
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30ec4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x30ec4
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30edf
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
void testing::internal::ContainerPrinter::PrintValue<std::array<bfy_iovec, 1ul>, void>(std::array<bfy_iovec, 1ul> const&, std::ostream*) | static void PrintValue(const T& container, std::ostream* os) {
const size_t kMaxCount = 32; // The maximum number of elements to print.
*os << '{';
size_t count = 0;
for (auto&& elem : container) {
if (count > 0) {
*os << ',';
if (count == kMaxCount) { // Enough has been printed.
*os << " ...";
break;
}
}
*os << ' ';
// We cannot call PrintTo(elem, os) here as PrintTo() doesn't
// handle `elem` being a native array.
internal::UniversalPrint(elem, os);
++count;
}
if (count > 0) {
*os << ' ';
}
*os << '}';
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
movb $0x7b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10560
movb $0x20, %bpl
leaq 0xd(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10560
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17921
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10560
leaq 0xf(%rsp), %rsi
movb $0x7d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10560
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest-printers.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char const*, void*>(char const*, char const*, char const* const&, void* const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rcx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x2eb4c
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x311e9
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x3906e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31179
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31194
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x311c6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x311c6
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x311e1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
void testing::internal::PointerPrinter::PrintValue<void>(void*, std::ostream*) | static void PrintValue(T* p, ::std::ostream* os) {
if (p == nullptr) {
*os << "NULL";
} else {
// T is not a function type. We just call << to print p,
// relying on ADL to pick up user-defined << for their pointer
// types, if any.
*os << p;
}
} | movq %rsi, %rcx
testq %rdi, %rdi
je 0x31282
movq %rdi, %rax
movq %rcx, %rdi
movq %rax, %rsi
jmp 0x10380
leaq 0x32399(%rip), %rsi # 0x63622
movl $0x4, %edx
movq %rcx, %rdi
jmp 0x10560
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest-printers.h |
testing::AssertionResult testing::internal::CmpHelperEQ<std::vector<bfy_iovec, std::allocator<bfy_iovec>>, std::vector<bfy_iovec, std::allocator<bfy_iovec>>>(char const*, char const*, std::vector<bfy_iovec, std::allocator<bfy_iovec>> const&, std::vector<bfy_iovec, std::allocator<bfy_iovec>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
} | pushq %rbx
movq %rdi, %rbx
movq (%rcx), %rdi
movq 0x8(%rcx), %rax
movq %rax, %r10
subq %rdi, %r10
movq (%r8), %r9
movq 0x8(%r8), %r11
subq %r9, %r11
cmpq %r11, %r10
jne 0x3151e
cmpq %rax, %rdi
sete %r10b
je 0x3150f
movq (%rdi), %r10
cmpq (%r9), %r10
jne 0x3151e
movq 0x8(%r9), %r10
cmpq %r10, 0x8(%rdi)
jne 0x3151e
addq $0x10, %rdi
addq $0x18, %r9
cmpq %rax, %rdi
sete %r10b
je 0x3150f
movq (%rdi), %r10
cmpq -0x8(%r9), %r10
jne 0x3151e
leaq 0x10(%rdi), %r10
movq (%r9), %r11
addq $0x10, %r9
cmpq %r11, 0x8(%rdi)
movq %r10, %rdi
je 0x314e7
jmp 0x3151e
testb %r10b, %r10b
je 0x3151e
movq %rbx, %rdi
callq 0x382ab
jmp 0x31526
movq %rbx, %rdi
callq 0x3152b
movq %rbx, %rax
popq %rbx
retq
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<std::vector<bfy_iovec, std::allocator<bfy_iovec>>, std::vector<bfy_iovec, std::allocator<bfy_iovec>>>(char const*, char const*, std::vector<bfy_iovec, std::allocator<bfy_iovec>> const&, std::vector<bfy_iovec, std::allocator<bfy_iovec>> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x31602
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x31602
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x3906e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31592
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x315ad
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x315df
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x315df
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x315fa
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
void testing::internal::ContainerPrinter::PrintValue<std::vector<bfy_iovec, std::allocator<bfy_iovec>>, void>(std::vector<bfy_iovec, std::allocator<bfy_iovec>> const&, std::ostream*) | static void PrintValue(const T& container, std::ostream* os) {
const size_t kMaxCount = 32; // The maximum number of elements to print.
*os << '{';
size_t count = 0;
for (auto&& elem : container) {
if (count > 0) {
*os << ',';
if (count == kMaxCount) { // Enough has been printed.
*os << " ...";
break;
}
}
*os << ' ';
// We cannot call PrintTo(elem, os) here as PrintTo() doesn't
// handle `elem` being a native array.
internal::UniversalPrint(elem, os);
++count;
}
if (count > 0) {
*os << ' ';
}
*os << '}';
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x5(%rsp), %rsi
movb $0x7b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10560
movq (%r15), %r14
movq 0x8(%r15), %rbp
cmpq %rbp, %r14
je 0x31753
xorl %r13d, %r13d
leaq 0x4(%rsp), %r15
leaq 0x3(%rsp), %r12
testq %r13, %r13
je 0x31707
movb $0x2c, 0x3(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10560
cmpq $0x20, %r13
jne 0x31707
movl $0x4, %edx
movq %rbx, %rdi
leaq 0x36ee1(%rip), %rsi # 0x685d9
callq 0x10560
movl $0x20, %r13d
movb $0x1, %al
jmp 0x3172c
movb $0x20, 0x4(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10560
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17921
incq %r13
xorl %eax, %eax
testb %al, %al
jne 0x31739
addq $0x10, %r14
cmpq %rbp, %r14
jne 0x316c9
testq %r13, %r13
je 0x31753
leaq 0x6(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10560
leaq 0x7(%rsp), %rsi
movb $0x7d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10560
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest-printers.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char*, void*>(char const*, char const*, char* const&, void* const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rcx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x2eb4c
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x311e9
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x3906e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31809
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31824
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31856
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x31856
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31871
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQ<std::basic_string_view<char, std::char_traits<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, std::basic_string_view<char, std::char_traits<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%rcx), %rdx
cmpq 0x8(%r8), %rdx
jne 0x31cb0
testq %rdx, %rdx
je 0x31cc6
movq 0x8(%r15), %rdi
movq (%r14), %rsi
callq 0x104b0
testl %eax, %eax
je 0x31cc6
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x31cdb
jmp 0x31cce
movq %rbx, %rdi
callq 0x382ab
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperOpFailure<char const*, void*>(char const*, char const*, char const* const&, void* const&, char const*) | AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
const T1& val1, const T2& val2,
const char* op) {
return AssertionFailure()
<< "Expected: (" << expr1 << ") " << op << " (" << expr2
<< "), actual: " << FormatForComparisonFailureMessage(val1, val2)
<< " vs " << FormatForComparisonFailureMessage(val2, val1);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq %rsp, %r12
movq %r12, %rdi
callq 0x382ba
leaq 0x31583(%rip), %rsi # 0x635e6
movq %r12, %rdi
callq 0x2e650
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x31573(%rip), %rsi # 0x635f2
movq %rax, %rdi
callq 0x2e75e
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x31554(%rip), %rsi # 0x635ef
movq %rax, %rdi
callq 0x2e75e
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x3153e(%rip), %rsi # 0x635f5
movq %rax, %rdi
callq 0x2e650
movq %rax, %r12
movq (%r15), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x48(%rsp), %rdi
callq 0x2eb4c
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x2e7dc
leaq 0x31516(%rip), %rsi # 0x63601
movq %rax, %rdi
callq 0x2e850
movq %rax, %r15
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x311e9
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x2e7dc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x381d8
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32136
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32151
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x32165
leaq 0x8(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x32198
jmp 0x321b8
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3219b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3219b
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x321bb
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x321bb
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x321cf
leaq 0x8(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperOpFailure<unsigned long, unsigned long>(char const*, char const*, unsigned long const&, unsigned long const&, char const*) | AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
const T1& val1, const T2& val2,
const char* op) {
return AssertionFailure()
<< "Expected: (" << expr1 << ") " << op << " (" << expr2
<< "), actual: " << FormatForComparisonFailureMessage(val1, val2)
<< " vs " << FormatForComparisonFailureMessage(val2, val1);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq %rsp, %r12
movq %r12, %rdi
callq 0x382ba
leaq 0x313da(%rip), %rsi # 0x635e6
movq %r12, %rdi
callq 0x2e650
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x313ca(%rip), %rsi # 0x635f2
movq %rax, %rdi
callq 0x2e75e
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x313ab(%rip), %rsi # 0x635ef
movq %rax, %rdi
callq 0x2e75e
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x31395(%rip), %rsi # 0x635f5
movq %rax, %rdi
callq 0x2e650
movq %rax, %r12
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x30997
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x2e7dc
leaq 0x31375(%rip), %rsi # 0x63601
movq %rax, %rdi
callq 0x2e850
movq %rax, %r15
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x30997
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x2e7dc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x381d8
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x322d7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x322f2
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x32306
leaq 0x8(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x32339
jmp 0x32359
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3233c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3233c
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3235c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3235c
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x32370
leaq 0x8(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperOpFailure<int, unsigned long>(char const*, char const*, int const&, unsigned long const&, char const*) | AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
const T1& val1, const T2& val2,
const char* op) {
return AssertionFailure()
<< "Expected: (" << expr1 << ") " << op << " (" << expr2
<< "), actual: " << FormatForComparisonFailureMessage(val1, val2)
<< " vs " << FormatForComparisonFailureMessage(val2, val1);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq %rsp, %r12
movq %r12, %rdi
callq 0x382ba
leaq 0x31239(%rip), %rsi # 0x635e6
movq %r12, %rdi
callq 0x2e650
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x31229(%rip), %rsi # 0x635f2
movq %rax, %rdi
callq 0x2e75e
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x3120a(%rip), %rsi # 0x635ef
movq %rax, %rdi
callq 0x2e75e
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x311f4(%rip), %rsi # 0x635f5
movq %rax, %rdi
callq 0x2e650
movq %rax, %r12
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x30914
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x2e7dc
leaq 0x311d4(%rip), %rsi # 0x63601
movq %rax, %rdi
callq 0x2e850
movq %rax, %r15
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x30997
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x2e7dc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x381d8
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32478
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32493
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x324a7
leaq 0x8(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x324da
jmp 0x324fa
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x324dd
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x324dd
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x324fd
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x324fd
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x32511
leaq 0x8(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQ<std::array<bfy_iovec, 2ul>, std::array<bfy_iovec, 2ul>>(char const*, char const*, std::array<bfy_iovec, 2ul> const&, std::array<bfy_iovec, 2ul> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
} | pushq %rbx
movq %rdi, %rbx
movq (%rcx), %rax
cmpq (%r8), %rax
jne 0x32556
movq 0x8(%r8), %rax
cmpq %rax, 0x8(%rcx)
jne 0x32556
xorl %eax, %eax
cmpq $0x10, %rax
je 0x32560
movq 0x10(%rcx,%rax), %rdi
cmpq 0x10(%r8,%rax), %rdi
jne 0x32556
movq 0x18(%r8,%rax), %rdi
leaq 0x10(%rax), %r9
cmpq %rdi, 0x18(%rcx,%rax)
movq %r9, %rax
je 0x32531
movq %rbx, %rdi
callq 0x3256d
jmp 0x32568
movq %rbx, %rdi
callq 0x382ab
movq %rbx, %rax
popq %rbx
retq
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<std::array<bfy_iovec, 2ul>, std::array<bfy_iovec, 2ul>>(char const*, char const*, std::array<bfy_iovec, 2ul> const&, std::array<bfy_iovec, 2ul> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x32644
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x32644
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x3906e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x325d4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x325ef
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32621
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x32621
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3263c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
void testing::internal::ContainerPrinter::PrintValue<std::array<bfy_iovec, 2ul>, void>(std::array<bfy_iovec, 2ul> const&, std::ostream*) | static void PrintValue(const T& container, std::ostream* os) {
const size_t kMaxCount = 32; // The maximum number of elements to print.
*os << '{';
size_t count = 0;
for (auto&& elem : container) {
if (count > 0) {
*os << ',';
if (count == kMaxCount) { // Enough has been printed.
*os << " ...";
break;
}
}
*os << ' ';
// We cannot call PrintTo(elem, os) here as PrintTo() doesn't
// handle `elem` being a native array.
internal::UniversalPrint(elem, os);
++count;
}
if (count > 0) {
*os << ' ';
}
*os << '}';
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5(%rsp), %rsi
movb $0x7b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10560
xorl %r13d, %r13d
leaq 0x4(%rsp), %r15
xorl %r12d, %r12d
testq %r13, %r13
je 0x32739
movb $0x2c, 0x3(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x3(%rsp), %rsi
callq 0x10560
cmpq $0x20, %r13
jne 0x32739
movl $0x4, %edx
movq %rbx, %rdi
leaq 0x35eaf(%rip), %rsi # 0x685d9
callq 0x10560
movl $0x20, %r13d
movb $0x1, %al
jmp 0x32762
leaq (%r14,%r12), %rbp
movb $0x20, 0x4(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10560
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x17921
incq %r13
xorl %eax, %eax
testb %al, %al
jne 0x32774
leaq 0x10(%r12), %rax
cmpq $0x10, %r12
movq %rax, %r12
jne 0x326f9
testq %r13, %r13
je 0x3278e
leaq 0x6(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10560
leaq 0x7(%rsp), %rsi
movb $0x7d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10560
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest-printers.h |
testing::AssertionResult testing::internal::CmpHelperEQ<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char*>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char* const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%r8), %rsi
movq %rcx, %rdi
callq 0x328de
movq %rbx, %rdi
testl %eax, %eax
je 0x327ef
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x32801
jmp 0x327f4
callq 0x382ab
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char*>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char* const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rcx, %rsi
callq 0x31db2
movq (%r12), %rax
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x3294a
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x3906e
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3286d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32888
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x328ba
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x328ba
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x328d5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::internal::UniversalTersePrinter<char const*>::Print(char const*, std::ostream*) | static void Print(const char* str, ::std::ostream* os) {
if (str == nullptr) {
*os << "NULL";
} else {
UniversalPrint(std::string(str), os);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x32a35
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0x101b0
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2e262
movq %r15, %rdi
movq %rbx, %rsi
callq 0x51f82
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x32a29
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x30be6(%rip), %rsi # 0x63622
movl $0x4, %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10560
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x32a6e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest-printers.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char*, char const*>(char const*, char const*, char* const&, char const* const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rcx), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x2eb4c
movq (%r12), %rax
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x2eb4c
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x3906e
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32b0b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32b26
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32b58
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x32b58
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32b73
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQ<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const*>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const* const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%r8), %rsi
movq %rcx, %rdi
callq 0x328de
movq %rbx, %rdi
testl %eax, %eax
je 0x32bb8
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x32bca
jmp 0x32bbd
callq 0x382ab
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const*>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const* const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rcx, %rsi
callq 0x31db2
movq (%r12), %rax
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x32ca6
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x3906e
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32c36
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32c51
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32c83
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x32c83
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32c9e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<unsigned int, unsigned int>(char const*, char const*, unsigned int const&, unsigned int const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x32fa1
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x32fa1
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x3906e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32f31
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32f4c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32f7e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x32f7e
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32f99
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQ<std::vector<char, std::allocator<char>>, std::vector<char, std::allocator<char>>>(char const*, char const*, std::vector<char, std::allocator<char>> const&, std::vector<char, std::allocator<char>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%rcx), %rdi
movq 0x8(%rcx), %rax
movq %rax, %rdx
subq %rdi, %rdx
movq (%r8), %rsi
movq 0x8(%r8), %rcx
subq %rsi, %rcx
cmpq %rcx, %rdx
jne 0x3336a
cmpq %rdi, %rax
je 0x33380
callq 0x104b0
testl %eax, %eax
je 0x33380
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x33395
jmp 0x33388
movq %rbx, %rdi
callq 0x382ab
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<std::vector<char, std::allocator<char>>, std::vector<char, std::allocator<char>>>(char const*, char const*, std::vector<char, std::allocator<char>> const&, std::vector<char, std::allocator<char>> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x3346c
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x3346c
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x3906e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x333fc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x33417
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x33449
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x33449
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x33464
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %r15
movq %r15, %rdi
movl $0x2f, %esi
callq 0x10510
movq %rax, %r14
testq %rax, %rax
setne %bpl
je 0x35e36
leaq 0x1(%r14), %r15
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r15, %rdi
callq 0x101b0
leaq (%r14,%rax), %rdx
incq %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x2e262
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x54486
jmp 0x35e50
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%r12), %rdx
addq %r15, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3078a
testq %r14, %r14
je 0x35e70
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35e70
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %bpl
jmp 0x35eae
movq %rax, %rbx
testq %r14, %r14
je 0x35eae
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
movb $0x1, %bpl
cmpq %rax, %rdi
je 0x35eae
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
testb %bpl, %bpl
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
movq 0x54912(%rip), %r14 # 0x8a850
leaq 0xc8(%rsp), %r15
movq %r15, %rdi
callq 0x35eba
cmpq $0x0, 0x8(%r15)
je 0x36335
movq %r14, %rdi
movl $0x3a, %esi
callq 0x10190
testq %rax, %rax
je 0x361d5
movq %rax, %r15
leaq 0x1(%rax), %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r14, %rdi
callq 0x101b0
leaq (%r15,%rax), %rdx
incq %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2e262
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x54486
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x35fc2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x28(%rsp), %rax
cmpb $0x2f, (%rax)
je 0x360ec
callq 0x3435e
movq 0x54954(%rip), %rax # 0x8a930
movq 0x10(%rax), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5424e
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x54486
leaq 0xb8(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x101b0
leaq (%rax,%r14), %rdx
leaq 0xa8(%rsp), %rdi
movq %r14, %rsi
callq 0x2e262
leaq 0x88(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x54486
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0x36a3e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5b212
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x36078
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36099
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0xa8(%rsp), %rdi
cmpq %r15, %rdi
je 0x360b6
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x360d1
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x360ec
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x30(%rsp), %rdx
testq %rdx, %rdx
je 0x361a2
movq 0x28(%rsp), %rax
cmpb $0x2f, -0x1(%rax,%rdx)
jne 0x361a2
leaq 0x68(%rsp), %rdi
callq 0x35ce5
leaq 0x48(%rsp), %rdi
callq 0x35eba
movq 0x48(%rsp), %rcx
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x36bea
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36152
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3616d
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3078a
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x361b9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x361b9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x28(%rsp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3078a
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36302
movq 0x38(%rsp), %rsi
jmp 0x362fa
callq 0x3435e
movq 0x5474f(%rip), %rax # 0x8a930
movq 0x10(%rax), %rsi
leaq 0x68(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0x5424e
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x54486
leaq 0x98(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x30271(%rip), %rsi # 0x6648a
leaq 0x30275(%rip), %rdx # 0x66495
leaq 0x88(%rsp), %rdi
callq 0x2e262
leaq 0x48(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x54486
movq 0xc8(%rsp), %r8
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
xorl %ecx, %ecx
callq 0x3659e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3078a
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36294
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x362af
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x88(%rsp), %rdi
cmpq %r14, %rdi
je 0x362cc
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x362e7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36302
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0xd8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36323
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x30196(%rip), %rsi # 0x664dc
leaq 0x30192(%rip), %rdx # 0x664df
leaq 0x28(%rsp), %rdi
callq 0x2e262
leaq 0xc8(%rsp), %rdi
leaq 0x28(%rsp), %r15
movq %r15, %rsi
callq 0x109d0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x35f59
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x35f59
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3653f
movq 0x18(%rsp), %rsi
jmp 0x36487
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x363c8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x363c8
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3653f
movq 0x78(%rsp), %rsi
jmp 0x36487
jmp 0x3653c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x36408
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x36408
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3642e
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3642e
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
cmpq %r15, %rdi
je 0x36450
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x36450
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36470
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x36470
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3653f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3653f
jmp 0x3653c
jmp 0x3653c
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x364c1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x364c1
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x364e1
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x364e1
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %r14, %rdi
je 0x36503
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x36503
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36523
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x36523
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36575
movq 0x78(%rsp), %rsi
jmp 0x36552
jmp 0x36572
jmp 0x36572
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36575
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x36575
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x36575
movq 0x18(%rsp), %rsi
jmp 0x36552
jmp 0x36572
movq %rax, %rbx
leaq 0xd8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36596
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::FilePath::ConcatPaths(testing::internal::FilePath const&, testing::internal::FilePath const&) | FilePath FilePath::ConcatPaths(const FilePath& directory,
const FilePath& relative_path) {
if (directory.IsEmpty())
return relative_path;
const FilePath dir(directory.RemoveTrailingPathSeparator());
return FilePath(dir.string() + kPathSeparator + relative_path.string());
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x36ad4
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x503aa
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3078a
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rsi
movl $0x1, %ecx
xorl %edx, %edx
movl $0x2f, %r8d
callq 0x5de62
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x2e9b4
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x36aef
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x36af6
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3078a
jmp 0x36b63
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x54486
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x36b31
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x36b48
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36b63
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x36b93
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x36b93
jmp 0x36b90
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x36baf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x36baf
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36bca
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest-filepath.cc |
testing::internal::UnitTestOptions::PatternMatchesString(char const*, char const*) | bool UnitTestOptions::PatternMatchesString(const char *pattern,
const char *str) {
switch (*pattern) {
case '\0':
case ':': // Either ':' or '\0' marks the end of the pattern.
return *str == '\0';
case '?': // Matches any single character.
return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
case '*': // Matches any string (possibly empty) of characters.
return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||
PatternMatchesString(pattern + 1, str);
default: // Non-special character. Matches itself.
return *pattern == *str &&
PatternMatchesString(pattern + 1, str + 1);
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1(%r15), %r14
movzbl (%rbx), %eax
cmpl $0x2a, %eax
jne 0x36cfb
cmpb $0x0, (%r15)
je 0x36cf6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36cca
testb %al, %al
jne 0x36d27
incq %rbx
jmp 0x36cd9
testl %eax, %eax
je 0x36d1e
cmpl $0x3f, %eax
je 0x36d10
cmpl $0x3a, %eax
je 0x36d1e
cmpb (%r15), %al
je 0x36d16
jmp 0x36d2f
cmpb $0x0, (%r15)
je 0x36d2f
incq %rbx
movq %r14, %r15
jmp 0x36cd5
cmpb $0x0, (%r15)
sete %al
jmp 0x36d29
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x36d29
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestOptions::FilterMatchesTest(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 UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name,
const std::string& test_name) {
const std::string& full_name = test_suite_name + "." + test_name.c_str();
// Split --gtest_filter at '-', if there is one, to separate into
// positive filter and negative filter portions
const char* const p = GTEST_FLAG(filter).c_str();
const char* const dash = strchr(p, '-');
std::string positive;
std::string negative;
if (dash == nullptr) {
positive = GTEST_FLAG(filter).c_str(); // Whole string is a positive filter
negative = "";
} else {
positive = std::string(p, dash); // Everything up to the dash
negative = std::string(dash + 1); // Everything after the dash
if (positive.empty()) {
// Treat '-test1' as the same as '*-test1'
positive = kUniversalFilter;
}
}
// A filter is a colon-separated list of patterns. It matches a
// test if any pattern in it matches the test.
return (MatchesFilter(full_name, positive.c_str()) &&
!MatchesFilter(full_name, negative.c_str()));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3078a
leaq 0x316ce(%rip), %rsi # 0x6849d
movq %r14, %rdi
callq 0x2e96e
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2e96e
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x36e0b
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x36e12
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x36e41
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x539e0(%rip), %rbx # 0x8a828
movq %rbx, %rdi
movl $0x2d, %esi
callq 0x10190
movq %rax, %r15
movq %rbp, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movb %al, 0x18(%rsp)
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
testq %r15, %r15
jne 0x36f41
movq %rbx, %rdi
callq 0x101b0
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
movq %rax, %r8
callq 0x2ec34
leaq 0x31280(%rip), %rcx # 0x68127
leaq 0x68(%rsp), %rbx
movq 0x8(%rbx), %rdx
xorl %r8d, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2ec34
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x36d34
testb %al, %al
je 0x36ee6
movq 0x68(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x36d34
movl %eax, %ebx
xorb $0x1, %bl
jmp 0x36ee8
xorl %ebx, %ebx
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x36eff
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x36f16
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x36f2d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2e262
leaq 0x8(%rsp), %rbx
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x10a74
movq %r13, %rax
leaq 0x1(%r15), %r13
leaq 0x48(%rsp), %rcx
movq %rax, (%rcx)
movq %r13, %rdi
callq 0x101b0
leaq (%r15,%rax), %rdx
incq %rdx
leaq 0x48(%rsp), %rdi
movq %r13, %rsi
callq 0x2e262
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %r15
movq %r15, %rsi
callq 0x109d0
movq (%r15), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x36fc6
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
jne 0x36ebd
movl $0x1, %r8d
leaq 0x2f4b5(%rip), %rcx # 0x66496
jmp 0x36eb3
jmp 0x37000
jmp 0x37000
jmp 0x36fec
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x37048
movq 0x18(%rsp), %rsi
jmp 0x37040
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x3701a
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x37031
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x37048
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() | ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
impl->SetGlobalTestPartResultReporter(old_reporter_);
} else {
impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
}
} | pushq %rbx
movq %rdi, %rbx
leaq 0x51bb9(%rip), %rax # 0x88d30
movq %rax, (%rdi)
callq 0x3435e
movq 0x537aa(%rip), %rdi # 0x8a930
cmpl $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rbx
jne 0x3719a
movq %rbx, %rsi
callq 0x37112
jmp 0x371a9
addq $0x90, %rdi
callq 0x5bb92
movq %rbx, (%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x2dd16
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult(testing::TestPartResult const&) | void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
const TestPartResult& result) {
unit_test_->current_test_result()->AddTestPartResult(result);
unit_test_->listeners()->repeater()->OnTestPartResult(result);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x170(%rax), %rdi
testq %rdi, %rdi
je 0x3765b
addq $0x90, %rdi
jmp 0x37679
movq 0x168(%rax), %rdi
testq %rdi, %rdi
je 0x37670
addq $0x88, %rdi
jmp 0x37679
addq $0x178, %rax # imm = 0x178
movq %rax, %rdi
addq $0x38, %rdi
movq %rbx, %rsi
callq 0x556f8
movq 0x8(%r14), %rax
movq 0x1f8(%rax), %rdi
movq (%rdi), %rax
movq 0x48(%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
nop
| /ckerr[P]buffy/extern/googletest/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 %rbx
movq %rdi, %rbx
cmpq $0x0, 0x210(%rdi)
jne 0x37cad
movl $0x8, %edi
callq 0x10470
leaq 0x513e5(%rip), %rcx # 0x89088
movq %rcx, (%rax)
movq %rax, 0x210(%rbx)
movq 0x210(%rbx), %rax
popq %rbx
retq
| /ckerr[P]buffy/extern/googletest/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;
} | movb $0x1, %al
retq
| /ckerr[P]buffy/extern/googletest/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x18, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x10350
movq (%r14), %r12
movq 0x8(%r14), %r13
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq (,%r13,2), %rsi
movq %rbx, %rdi
callq 0x554f4
testq %r13, %r13
je 0x3816f
xorl %ebp, %ebp
leaq 0x2f9f3(%rip), %r14 # 0x67b3a
movb (%r12,%rbp), %al
testb %al, %al
je 0x3815c
movsbl %al, %esi
movq %rbx, %rdi
callq 0x562f2
jmp 0x38167
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e96e
incq %rbp
cmpq %rbp, %r13
jne 0x38147
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3818a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3819e
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x381b4
movq (%r15), %rsi
incq %rsi
callq 0x10490
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x381cf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq %r14, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::AssertionResult::operator!() const | AssertionResult AssertionResult::operator!() const {
AssertionResult negation(!success_);
if (message_.get() != nullptr) negation << *message_;
return negation;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movb (%rsi), %al
xorb $0x1, %al
movb %al, (%rdi)
movq $0x0, 0x8(%rdi)
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x3827e
leaq 0x8(%r14), %rbx
movq %r14, %rdi
callq 0x2e7dc
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x3829c
movq %rbx, %rdi
callq 0x2dd22
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x58748
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x38981
movq 0x40(%rax), %r15
jmp 0x38993
movq 0x28(%r14), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x586cc
movq %r15, (%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
| /ckerr[P]buffy/extern/googletest/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x2d, %esi
je 0x38fbd
cmpl $0x2b, %ebp
je 0x38fab
cmpl $0x20, %ebp
jne 0x38ff1
incq 0x20(%rbx)
movq %rbx, %rdi
callq 0x52a44
movl $0x38, %r12d
movl $0x28, %r15d
jmp 0x38fcd
incq 0x10(%rbx)
movl $0x50, %r12d
movl $0x40, %r15d
jmp 0x38fcd
incq 0x18(%rbx)
movl $0x68, %r12d
movl $0x58, %r15d
addq %rbx, %r15
movl $0x20, %edi
callq 0x10470
movb %bpl, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x10090
incq (%rbx,%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /ckerr[P]buffy/extern/googletest/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %ebp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x30(%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x37e78
movq (%rbx), %rdi
addq $0x10, %rdi
leaq 0x2e889(%rip), %rsi # 0x67934
movl $0x22, %edx
callq 0x10560
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x2e892(%rip), %rsi # 0x67957
movl $0x3, %edx
callq 0x10560
movq 0x8(%rsp), %rbx
addq $0x10, %rbx
testq %r13, %r13
je 0x390ed
movq %r13, %rdi
callq 0x101b0
movq %rax, %rdx
movq %r13, %rsi
jmp 0x390f9
movl $0x6, %edx
leaq 0x2a522(%rip), %rsi # 0x6361b
movq %rbx, %rdi
callq 0x10560
movq %r15, %rdi
movq %r13, %rsi
callq 0x328de
testl %eax, %eax
je 0x3913f
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x2e83b(%rip), %rsi # 0x6795b
movl $0xf, %edx
callq 0x10560
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq (%r15), %rsi
movq 0x8(%r15), %rdx
callq 0x10560
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x2e808(%rip), %rsi # 0x67957
movl $0x3, %edx
callq 0x10560
movq 0x8(%rsp), %rbx
addq $0x10, %rbx
testq %r12, %r12
je 0x39177
movq %r12, %rdi
callq 0x101b0
movq %rax, %rdx
movq %r12, %rsi
jmp 0x39183
movl $0x6, %edx
leaq 0x2a498(%rip), %rsi # 0x6361b
movq %rbx, %rdi
callq 0x10560
movq %r14, %rdi
movq %r12, %rsi
callq 0x328de
testl %eax, %eax
je 0x391c9
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x2e7b1(%rip), %rsi # 0x6795b
movl $0xf, %edx
callq 0x10560
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x10560
testb %bpl, %bpl
je 0x391e8
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x2e78d(%rip), %rsi # 0x6796b
movl $0xe, %edx
callq 0x10560
cmpq $0x0, 0x8(%r15)
movq 0x30(%rsp), %rbx
je 0x392b7
cmpq $0x0, 0x8(%r14)
je 0x392b7
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0x3938a
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x3938a
movq 0x58(%rsp), %rax
subq 0x50(%rsp), %rax
cmpq $0x20, %rax
ja 0x3923d
movq 0x40(%rsp), %rax
subq 0x38(%rsp), %rax
cmpq $0x21, %rax
jb 0x392a3
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x2e72d(%rip), %rsi # 0x6797a
movl $0xc, %edx
callq 0x10560
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movl $0x2, %ecx
callq 0x3899c
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x10560
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x392a3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x38(%rsp), %rdi
callq 0x543a0
leaq 0x50(%rsp), %rdi
callq 0x543a0
leaq 0x18(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x544d4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x381d8
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x392f4
movq %r14, %rdi
callq 0x2dd22
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x39304
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 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3933b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3933b
jmp 0x39338
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x543a0
jmp 0x3934a
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x543a0
jmp 0x39372
jmp 0x3936f
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x39372
movq %r14, %rdi
callq 0x2dd22
jmp 0x39372
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x39382
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/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
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 0x393d3
movq (%r14), %rax
cmpb $0x22, (%rax)
jne 0x393d3
xorl %edx, %edx
cmpb $0x22, -0x1(%rax,%r15)
leaq -0x1(%r15), %rax
sete %dl
cmoveq %rax, %r15
jmp 0x393d5
xorl %edx, %edx
leaq 0x1(%rdx), %rbp
cmpq %r15, %rbp
jae 0x3944a
leaq 0x18(%rsp), %r13
xorl %eax, %eax
leaq 0x8(%rsp), %r12
movq (%r14), %rcx
movb -0x1(%rcx,%rbp), %cl
testb $0x1, %al
je 0x39438
cmpb $0x6e, %cl
jne 0x39440
movq %rbp, %rcx
subq %rdx, %rcx
addq $-0x2, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x2d37e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5bd10
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x39431
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
xorl %eax, %eax
movq %rbp, %rdx
jmp 0x39442
cmpb $0x5c, %cl
sete %al
jmp 0x39442
xorl %eax, %eax
incq %rbp
cmpq %rbp, %r15
jne 0x393ea
subq %rdx, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x2d37e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5bd10
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39485
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x394b9
jmp 0x394cb
jmp 0x394c8
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x394cb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x394cb
movq %rax, %r14
movq %rbx, %rdi
callq 0x543a0
movq %r14, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x39505
movq (%rax), %r13
jmp 0x3950c
leaq 0x2ec1b(%rip), %r13 # 0x68127
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x37e78
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x2e460(%rip), %rsi # 0x67987
movl $0xa, %edx
movq %r12, %rdi
callq 0x10560
testq %rbx, %rbx
je 0x39546
movq %rbx, %rdi
callq 0x101b0
movq %rax, %rdx
jmp 0x39552
movl $0x6, %edx
leaq 0x2a0c9(%rip), %rbx # 0x6361b
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10560
leaq 0x2e42e(%rip), %rsi # 0x67992
movl $0xb, %edx
movq %r12, %rdi
callq 0x10560
testq %rbp, %rbp
je 0x39583
movq %rbp, %rdi
callq 0x101b0
movq %rax, %rdx
jmp 0x3958f
movl $0x6, %edx
leaq 0x2a08c(%rip), %rbp # 0x6361b
movq %r12, %rdi
movq %rbp, %rsi
callq 0x10560
cmpb $0x0, (%r13)
je 0x395df
leaq 0x2a047(%rip), %rsi # 0x635ef
movl $0x2, %edx
movq %r12, %rdi
callq 0x10560
movq %r13, %rdi
callq 0x101b0
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x10560
leaq 0x28477(%rip), %rsi # 0x61a49
movl $0x1, %edx
movq %r12, %rdi
callq 0x10560
leaq 0x2e3b8(%rip), %rsi # 0x6799e
movl $0xb, %edx
movq %r12, %rdi
callq 0x10560
testq %r15, %r15
je 0x39605
movq %r15, %rdi
callq 0x101b0
movq %rax, %rdx
jmp 0x39611
movl $0x6, %edx
leaq 0x2a00a(%rip), %r15 # 0x6361b
movq %r12, %rdi
movq %r15, %rsi
callq 0x10560
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x380ed
testq %r14, %r14
je 0x39637
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0x3965c
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::CmpHelperEQ(char const*, char const*, long long, long long) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
BiggestInt lhs,
BiggestInt rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
cmpq %r8, %rcx
jne 0x39a3d
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x39ab0
movq %rdx, %r14
movq %rsi, %r15
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5c587
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x5c587
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x3906e
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39a95
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39ab0
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39ae0
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x39ae0
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39afb
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r9, %r15
movq %r8, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq (%r8), %rsi
movq (%r9), %rdi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %cl, %al
jne 0x3a823
cmpq %rdi, %rsi
sete %al
jmp 0x3a82e
callq 0x100d0
testq %rax, %rax
setne %al
cmpb %bpl, %al
je 0x3a966
leaq 0x2dca3(%rip), %rax # 0x684e1
movq %rax, (%rsp)
leaq 0x10(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x2d12d(%rip), %rsi # 0x67987
leaq 0x8(%rsp), %rdi
callq 0x5840c
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x2d8ae(%rip), %rsi # 0x68126
movq %rax, %rdi
callq 0x54d5c
leaq 0x2d10c(%rip), %rsi # 0x67993
movq %rax, %rdi
callq 0x5840c
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2e6ce
movq %rax, %rdi
movq %r12, %rsi
callq 0x2e6ce
leaq 0x2dc48(%rip), %rsi # 0x684f4
movq %rax, %rdi
callq 0x2e75e
leaq 0x2d0e4(%rip), %rsi # 0x6799f
movq %rax, %rdi
callq 0x5840c
leaq 0x2d85d(%rip), %rcx # 0x68127
leaq 0x2f11f(%rip), %rdx # 0x699f0
testb %bpl, %bpl
cmovneq %rcx, %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0x2e6ce
leaq 0x2f106(%rip), %rsi # 0x699f5
movq %rax, %rdi
callq 0x5c60a
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x2d81b(%rip), %rsi # 0x68126
movq %rax, %rdi
callq 0x54d5c
leaq 0x2d046(%rip), %rsi # 0x67960
movq %rax, %rdi
callq 0x5840c
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2e6ce
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e6ce
leaq 0x2dba2(%rip), %rsi # 0x684e1
movq %rax, %rdi
callq 0x54d5c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x381d8
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x3a971
movq %r14, %rdi
callq 0x2dd22
jmp 0x3a971
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a983
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x3a998
movq %r14, %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r9, %r15
movq %r8, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq (%r8), %rsi
movq 0x8(%r8), %rcx
movq %r9, %rdi
xorl %edx, %edx
callq 0x5c6f4
cmpq $-0x1, %rax
setne %al
xorb %bpl, %al
je 0x3ad85
leaq 0x2d884(%rip), %rax # 0x684e1
movq %rax, (%rsp)
leaq 0x10(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x2cd0e(%rip), %rsi # 0x67987
leaq 0x8(%rsp), %rdi
callq 0x5840c
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x2d48f(%rip), %rsi # 0x68126
movq %rax, %rdi
callq 0x54d5c
leaq 0x2cced(%rip), %rsi # 0x67993
movq %rax, %rdi
callq 0x5840c
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2e6ce
movq %rax, %rdi
movq %r12, %rsi
callq 0x2e7dc
leaq 0x2d829(%rip), %rsi # 0x684f4
movq %rax, %rdi
callq 0x2e75e
leaq 0x2ccc5(%rip), %rsi # 0x6799f
movq %rax, %rdi
callq 0x5840c
leaq 0x2d43e(%rip), %rcx # 0x68127
leaq 0x2ed00(%rip), %rdx # 0x699f0
testb %bpl, %bpl
cmovneq %rcx, %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0x2e6ce
leaq 0x2ece7(%rip), %rsi # 0x699f5
movq %rax, %rdi
callq 0x5c60a
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x2d3fc(%rip), %rsi # 0x68126
movq %rax, %rdi
callq 0x54d5c
leaq 0x2cc27(%rip), %rsi # 0x67960
movq %rax, %rdi
callq 0x5840c
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2e6ce
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e7dc
leaq 0x2d783(%rip), %rsi # 0x684e1
movq %rax, %rdi
callq 0x54d5c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x381d8
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x3ad90
movq %r14, %rdi
callq 0x2dd22
jmp 0x3ad90
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ada2
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x3adb7
movq %r14, %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $0x200000, %esi # imm = 0x200000
jb 0x3b020
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x3b1c8
leaq 0x2cb3f(%rip), %rcx # 0x67b26
movl $0x13, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2ebfa
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3b05e
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x3b065
cmpl $0x7f, %esi
ja 0x3b034
movb $0x0, 0x9(%rsp)
movb %sil, 0x8(%rsp)
jmp 0x3b133
cmpl $0x7ff, %esi # imm = 0x7FF
ja 0x3b100
movb $0x0, 0xa(%rsp)
movl %esi, %eax
shrl $0x6, %eax
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x9(%rsp)
orb $-0x40, %al
jmp 0x3b12f
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x269c1(%rip), %rsi # 0x61a49
callq 0x2e96e
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x3b0af
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x3b0b5
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 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3b0e3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b15a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3b15a
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 0x3b165
movb $0x0, 0xb(%rsp)
movb %dl, 0xa(%rsp)
movb %cl, 0x9(%rsp)
orb $-0x20, %al
movb %al, 0x8(%rsp)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x101b0
leaq (%rsp,%rax), %rdx
addq $0x8, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e262
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movb $0x0, 0xc(%rsp)
movb %dl, 0xb(%rsp)
movb %cl, 0xa(%rsp)
shrl $0x12, %esi
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x9(%rsp)
orb $-0x10, %sil
jmp 0x3b02a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3b1a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3b1a5
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b1c0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
cmpl $-0x1, %edx
jne 0x3b294
movq %r14, %rdi
callq 0x103d0
movq %rax, %r12
leaq 0x30(%rsp), %rdi
callq 0x10310
testl %r12d, %r12d
jle 0x3b306
leaq 0x40(%rsp), %r15
movl %r12d, %ebx
decq %rbx
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movl (%r14,%r13,4), %ebp
testl %ebp, %ebp
je 0x3b306
movq %r12, %rdi
movl %ebp, %esi
callq 0x3afc1
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x10560
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3b2f6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
testl %ebp, %ebp
je 0x3b306
leaq 0x1(%r13), %rax
cmpq %r13, %rbx
movq %rax, %r13
jne 0x3b2b6
leaq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x380ed
movq 0x4ec71(%rip), %rsi # 0x89f90
leaq 0x30(%rsp), %rdi
callq 0x10360
leaq 0xb0(%rsp), %rdi
callq 0x10140
movq %rbx, %rax
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b36e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3b371
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3b371
movq %rax, %rbx
movq 0x4ec18(%rip), %rsi # 0x89f90
leaq 0x30(%rsp), %rdi
callq 0x10360
leaq 0xb0(%rsp), %rdi
callq 0x10140
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/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 %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0x3b513
testq %r8, %r8
je 0x3b614
movq %rcx, %rdi
movq %r8, %rsi
callq 0x10660
testl %eax, %eax
sete %al
testb %al, %al
je 0x3b614
leaq 0x8(%rsp), %rbx
movb $0x0, -0x8(%rbx)
movq $0x0, (%rbx)
leaq 0x280b4(%rip), %rsi # 0x635e6
movq %rsp, %rdi
callq 0x2e650
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x2c593(%rip), %rsi # 0x67ae1
movq %rax, %rdi
callq 0x54cde
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x2e6ce
leaq 0x2808b(%rip), %rsi # 0x635f5
movq %rax, %rdi
callq 0x2e650
movq %rax, %r15
leaq 0x50(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x55470
leaq 0x50(%rsp), %rsi
movq %r15, %rdi
callq 0x2e7dc
leaq 0x28069(%rip), %rsi # 0x63601
movq %rax, %rdi
callq 0x2e850
movq %rax, %r15
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x55470
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x2e7dc
movq %r14, %rdi
movq %rax, %rsi
callq 0x381d8
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b5e5
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b600
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x3b620
movq %rbx, %rdi
callq 0x2dd22
jmp 0x3b620
movb $0x1, (%r14)
movq $0x0, 0x8(%r14)
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3b651
jmp 0x3b671
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b654
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3b654
movq %rax, %r14
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b674
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3b674
movq %rax, %r14
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x3b686
movq %rbx, %rdi
callq 0x2dd22
movq %r14, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x10310
movq 0x10(%r15), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r15
addq $0x10, %r15
cmpb $0x0, 0xe1(%r15)
jne 0x3b76e
movq %r15, %rdi
movl $0x20, %esi
callq 0x10450
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
leaq 0x10(%rsp), %rdi
movb $0x30, 0xe0(%r15)
movq (%rdi), %rax
movq -0x18(%rax), %rax
movslq %r14d, %rcx
movq %rcx, 0x20(%rsp,%rax)
movl %ebp, %esi
callq 0x10880
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x10350
movq 0x4e7eb(%rip), %rsi # 0x89f90
movq %rsp, %rdi
callq 0x10360
leaq 0x80(%rsp), %rdi
callq 0x10140
movq %rbx, %rax
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x4e7bb(%rip), %rsi # 0x89f90
movq %rsp, %rdi
callq 0x10360
leaq 0x80(%rsp), %rdi
callq 0x10140
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/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 %rax
testl %esi, %esi
js 0x3b987
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
imull $0xb6db6db7, %ecx, %ecx # imm = 0xB6DB6DB7
cmpl %esi, %ecx
jle 0x3b987
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 0x3b98c
imulq $0x70, %rsi, %rcx
addq %rcx, %rax
popq %rcx
retq
callq 0x556f1
leaq 0x2e075(%rip), %rdi # 0x69a08
xorl %eax, %eax
callq 0x107c0
| /ckerr[P]buffy/extern/googletest/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_properites_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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3bb90
testb %al, %al
je 0x3bb15
movq %rbx, %rdi
callq 0x58578
movq 0x50(%rbx), %r15
movq 0x58(%rbx), %r12
movq (%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5424e
leaq 0x40(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x3078a
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x55724
movq %rax, %r15
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x3baa2
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x20(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x3babe
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
cmpq 0x58(%rbx), %r15
je 0x3bb01
movq 0x20(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5424e
addq $0x20, %r15
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x5b212
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x3bb0d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3bb0d
leaq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x5589e
movq %rbx, %rdi
callq 0x58616
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3bb74
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
jne 0x3bb65
jmp 0x3bb77
jmp 0x3bb74
jmp 0x3bb87
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x3bb57
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3bb57
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3bb77
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3bb77
movq %rax, %r14
movq %rbx, %rdi
callq 0x58616
movq %r14, %rdi
callq 0x108a0
movq %rax, %rdi
callq 0x2dd16
nop
| /ckerr[P]buffy/extern/googletest/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 %rbx
movq %rdi, %rbx
addq $0x38, %rdi
movq 0x38(%rbx), %rsi
callq 0x5c91a
leaq 0x50(%rbx), %rdi
movq 0x50(%rbx), %rsi
callq 0x5cfe4
movl $0x0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
popq %rbx
retq
nop
| /ckerr[P]buffy/extern/googletest/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
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x37e78
movq (%rbx), %rbx
leaq 0x10(%rbx), %rdi
movl %ebp, %esi
callq 0x10880
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x380ed
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5424e
callq 0x3435e
leaq 0x4e669(%rip), %rdi # 0x8a8f0
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
callq 0x3c1bc
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c2af
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c2ca
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
testq %rbx, %rbx
je 0x3c2d8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
jmp 0x3c30b
jmp 0x3c2e8
movq %rax, %r14
jmp 0x3c326
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c30b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c326
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
testq %rbx, %rbx
je 0x3c334
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::Test::HasSameFixtureClass() | int UnitTestImpl::test_to_run_count() const {
return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
callq 0x3435e
movq 0x4e546(%rip), %rax # 0x8a930
movq 0x168(%rax), %rcx
movq 0x170(%rax), %rbp
movq 0x30(%rcx), %rax
movq (%rax), %rax
movq 0x78(%rax), %rcx
movq 0x78(%rbp), %rdx
cmpq %rcx, %rdx
je 0x3c78e
movq 0x20(%rax), %r14
movq 0x20(%rbp), %r13
leaq 0x4e5c2(%rip), %rax # 0x8a9e1
cmpq %rax, %rcx
movq %rcx, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
je 0x3c48c
cmpq %rax, %rdx
je 0x3c48c
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x37e78
movq (%rbx), %rbx
leaq 0x10(%rbx), %r15
leaq 0x2b6ef(%rip), %rsi # 0x67b3d
movl $0x40, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2b801(%rip), %rsi # 0x67c63
movl $0x1f, %edx
movq %r15, %rdi
callq 0x10560
movq (%rbp), %r12
testq %r12, %r12
je 0x3c500
movq %r12, %rdi
callq 0x101b0
movq %rax, %rdx
jmp 0x3c50c
cmpq %rax, %rcx
movq %r13, %r12
cmoveq %r14, %r12
cmoveq %r13, %r14
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x37e78
movq (%rbx), %rbx
leaq 0x10(%rbx), %r15
leaq 0x2b688(%rip), %rsi # 0x67b3d
movl $0x40, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2b6b5(%rip), %rsi # 0x67b7e
movl $0x3b, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2b6dd(%rip), %rsi # 0x67bba
movl $0x18, %edx
movq %r15, %rdi
callq 0x10560
movq (%rbp), %r13
testq %r13, %r13
je 0x3c551
movq %r13, %rdi
callq 0x101b0
movq %rax, %rdx
jmp 0x3c55d
movl $0x6, %edx
leaq 0x2710f(%rip), %r12 # 0x6361b
movq %r15, %rdi
movq %r12, %rsi
callq 0x10560
leaq 0x2bfc6(%rip), %rsi # 0x684e4
movl $0x2, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2b751(%rip), %rsi # 0x67c83
movl $0x11, %edx
movq %r15, %rdi
callq 0x10560
testq %r14, %r14
je 0x3c5a2
movq %r14, %rdi
callq 0x101b0
movq %rax, %rdx
jmp 0x3c5ae
movl $0x6, %edx
leaq 0x270be(%rip), %r13 # 0x6361b
movq %r15, %rdi
movq %r13, %rsi
callq 0x10560
leaq 0x2bf75(%rip), %rsi # 0x684e4
movl $0x2, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2b70c(%rip), %rsi # 0x67c8f
movl $0x5, %edx
movq %r15, %rdi
callq 0x10560
testq %r14, %r14
je 0x3c5df
movq %r14, %rdi
callq 0x101b0
movq %rax, %rdx
jmp 0x3c5eb
movl $0x6, %edx
leaq 0x2706d(%rip), %r14 # 0x6361b
movq %r15, %rdi
movq %r14, %rsi
callq 0x10560
leaq 0x2b6d5(%rip), %rsi # 0x67c95
movl $0xa, %edx
movq %r15, %rdi
callq 0x10560
testq %r13, %r13
je 0x3c637
movq %r13, %rdi
callq 0x101b0
movq %rax, %rdx
jmp 0x3c643
movl $0x6, %edx
leaq 0x27030(%rip), %r14 # 0x6361b
movq %r15, %rdi
movq %r14, %rsi
callq 0x10560
leaq 0x2b5d6(%rip), %rsi # 0x67bd3
movl $0x1d, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2b67e(%rip), %rsi # 0x67c8f
movl $0x5, %edx
movq %r15, %rdi
callq 0x10560
testq %r12, %r12
je 0x3c6e8
movq %r12, %rdi
callq 0x101b0
movq %rax, %rdx
jmp 0x3c6f4
movl $0x6, %edx
leaq 0x26fd8(%rip), %r13 # 0x6361b
movq %r15, %rdi
movq %r13, %rsi
callq 0x10560
leaq 0x2bad1(%rip), %rsi # 0x68126
movl $0x1, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2b637(%rip), %rsi # 0x67ca0
movl $0x3e, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2b662(%rip), %rsi # 0x67cdf
movl $0x3d, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2b68c(%rip), %rsi # 0x67d1d
movl $0x3e, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2b6b7(%rip), %rsi # 0x67d5c
movl $0x3b, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2ae6b(%rip), %rdx # 0x67524
leaq 0x2b59c(%rip), %r8 # 0x67c5c
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x9d4, %ecx # imm = 0x9D4
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
jmp 0x3c76c
movl $0x6, %edx
leaq 0x26f27(%rip), %r12 # 0x6361b
movq %r15, %rdi
movq %r12, %rsi
callq 0x10560
leaq 0x2b4eb(%rip), %rsi # 0x67bf1
movl $0x26, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2b4fe(%rip), %rsi # 0x67c18
movl $0x3d, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2b528(%rip), %rsi # 0x67c56
movl $0x5, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2ade2(%rip), %rdx # 0x67524
leaq 0x2b513(%rip), %r8 # 0x67c5c
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x9c8, %ecx # imm = 0x9C8
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
testq %rbx, %rbx
je 0x3c784
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rdx
cmpq %rcx, %rdx
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c7a5
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3423a
jmp 0x3c7c1
jmp 0x3c7be
jmp 0x3c7be
jmp 0x3c7be
jmp 0x3c7be
jmp 0x3c7be
movq %rax, %r14
testq %rbx, %rbx
je 0x3c7cf
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x37e78
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x3c877
movq 0x8(%r15), %rsi
movl 0x28(%r15), %edx
leaq 0x10(%rsp), %rdi
callq 0x3d2e8
movq 0x8(%rsp), %r14
leaq 0x10(%r14), %r12
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x10560
leaq 0x2b0b2(%rip), %rsi # 0x67959
movl $0x1, %edx
movq %r12, %rdi
callq 0x10560
movl (%r15), %eax
cmpq $0x3, %rax
ja 0x3c8cd
leaq 0x2abb0(%rip), %rcx # 0x67474
movslq (%rcx,%rax,4), %r13
addq %rcx, %r13
jmp 0x3c8d4
leaq 0x2c999(%rip), %r13 # 0x6926d
movq %r13, %rdi
callq 0x101b0
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x10560
movq 0x50(%r15), %r15
testq %r15, %r15
je 0x3c900
movq %r15, %rdi
callq 0x101b0
movq %rax, %rdx
jmp 0x3c90c
movl $0x6, %edx
leaq 0x26d0f(%rip), %r15 # 0x6361b
movq %r12, %rdi
movq %r15, %rsi
callq 0x10560
movq %rbx, %rdi
movq %r14, %rsi
callq 0x380ed
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c93d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
testq %r14, %r14
je 0x3c94b
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3c965
movq %rax, %rbx
jmp 0x3c983
jmp 0x3c965
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c983
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3c993
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::Test::HasFatalFailure() | bool Test::HasFatalFailure() {
return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
} | pushq %rax
callq 0x3435e
movq 0x4de6d(%rip), %rcx # 0x8a930
movq 0x170(%rcx), %rax
testq %rax, %rax
je 0x3cad7
addq $0x90, %rax
jmp 0x3caf5
movq 0x168(%rcx), %rax
testq %rax, %rax
je 0x3caeb
addq $0x88, %rax
jmp 0x3caf5
addq $0x178, %rcx # imm = 0x178
movq %rcx, %rax
movq 0x38(%rax), %rcx
movq 0x40(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x3cb1d
xorl %esi, %esi
cmpl $0x2, (%rcx)
sete %sil
addl %esi, %eax
addq $0x70, %rcx
cmpq %rdx, %rcx
jne 0x3cb04
testl %eax, %eax
setne %al
popq %rcx
retq
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::Test::HasNonfatalFailure() | bool Test::HasNonfatalFailure() {
return internal::GetUnitTestImpl()->current_test_result()->
HasNonfatalFailure();
} | pushq %rax
callq 0x3435e
movq 0x4ddbd(%rip), %rcx # 0x8a930
movq 0x170(%rcx), %rax
testq %rax, %rax
je 0x3cb87
addq $0x90, %rax
jmp 0x3cba5
movq 0x168(%rcx), %rax
testq %rax, %rax
je 0x3cb9b
addq $0x88, %rax
jmp 0x3cba5
addq $0x178, %rcx # imm = 0x178
movq %rcx, %rax
movq 0x38(%rax), %rcx
movq 0x40(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x3cbcd
xorl %esi, %esi
cmpl $0x1, (%rcx)
sete %sil
addl %esi, %eax
addq $0x70, %rcx
cmpq %rdx, %rcx
jne 0x3cbb4
testl %eax, %eax
setne %al
popq %rcx
retq
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::TestInfo::~TestInfo() | TestInfo::~TestInfo() { delete factory_; } | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x88(%rdi), %rdi
testq %rdi, %rdi
je 0x3ce0f
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x90(%rbx), %r14
leaq 0xe0(%rbx), %rdi
callq 0x55610
leaq 0xc8(%rbx), %rdi
callq 0x55640
movq %r14, %rdi
callq 0x55670
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x3ce4e
movq (%rax), %rsi
incq %rsi
callq 0x10490
movq 0x48(%rbx), %rsi
testq %rsi, %rsi
je 0x3ce60
leaq 0x48(%rbx), %rdi
callq 0x5d1c0
movq $0x0, 0x48(%rbx)
movq 0x40(%rbx), %rsi
testq %rsi, %rsi
je 0x3ce7a
leaq 0x40(%rbx), %rdi
callq 0x5d1c0
movq $0x0, 0x40(%rbx)
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x3ce9a
movq (%rax), %rsi
incq %rsi
callq 0x10490
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x3ceb8
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10490
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /ckerr[P]buffy/extern/googletest/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x37e78
movq (%rbx), %rbx
leaq 0x10(%rbx), %r15
leaq 0x2ad24(%rip), %rsi # 0x67db9
movl $0x25, %edx
movq %r15, %rdi
callq 0x10560
testq %r12, %r12
je 0x3d0b7
movq %r12, %rdi
callq 0x101b0
movq %rax, %rdx
movq %r12, %rsi
jmp 0x3d0c3
movl $0x6, %edx
leaq 0x26558(%rip), %rsi # 0x6361b
movq %r15, %rdi
callq 0x10560
leaq 0x2afa3(%rip), %rsi # 0x68075
movl $0x2, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2aa57(%rip), %rsi # 0x67b3d
movl $0x40, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2ab69(%rip), %rsi # 0x67c63
movl $0x1f, %edx
movq %r15, %rdi
callq 0x10560
testq %r12, %r12
je 0x3d119
movq %r12, %rdi
callq 0x101b0
movq %rax, %rdx
jmp 0x3d125
movl $0x6, %edx
leaq 0x264f6(%rip), %r12 # 0x6361b
movq %r15, %rdi
movq %r12, %rsi
callq 0x10560
leaq 0x2aca8(%rip), %rsi # 0x67ddf
movl $0xc, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2aca1(%rip), %rsi # 0x67dec
movl $0x3e, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2accc(%rip), %rsi # 0x67e2b
movl $0x3d, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2acf6(%rip), %rsi # 0x67e69
movl $0x3d, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2ad20(%rip), %rsi # 0x67ea7
movl $0x43, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2abf0(%rip), %rsi # 0x67d8b
movl $0xc, %edx
movq %r15, %rdi
callq 0x10560
leaq 0x2a375(%rip), %rdx # 0x67524
leaq 0xc(%rsp), %rdi
movl $0x2, %esi
movl $0xada, %ecx # imm = 0xADA
callq 0x515a8
movq (%r14), %rsi
movl 0x20(%r14), %edx
leaq 0x38(%rsp), %rdi
callq 0x3d2e8
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x4ce03(%rip), %rdi # 0x89fe8
callq 0x10560
movq %rax, %r14
leaq 0x2a765(%rip), %rsi # 0x67959
movl $0x1, %edx
movq %rax, %rdi
callq 0x10560
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x380ed
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r14, %rdi
callq 0x10560
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d23b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d256
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0xc(%rsp), %rdi
callq 0x516ea
testq %rbx, %rbx
je 0x3d26e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d2a6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3d2a6
jmp 0x3d2a3
movq %rax, %rbx
jmp 0x3d2c1
jmp 0x3d2cd
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d2c1
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0xc(%rsp), %rdi
callq 0x516ea
jmp 0x3d2d0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3d2e0
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.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 0x3d5f7
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xe8(%rdi), %r14
movq 0xf0(%rdi), %r15
cmpq %r15, %r14
je 0x3d5df
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x8, %r14
jmp 0x3d5cb
leaq 0x100(%rbx), %rdi
callq 0x354e0
movb $0x1, 0x160(%rbx)
popq %rbx
popq %r14
popq %r15
retq
| /ckerr[P]buffy/extern/googletest/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
cmpl $0x1, 0x4c680(%rip) # 0x8a878
je 0x3e20c
incl %edx
leaq 0x29dce(%rip), %rdi # 0x67fd1
movl %edx, %esi
xorl %eax, %eax
callq 0x10070
movq 0x4c615(%rip), %r14 # 0x8a828
testq %r14, %r14
je 0x3e22b
leaq 0x28277(%rip), %rsi # 0x66496
movq %r14, %rdi
callq 0x10700
testl %eax, %eax
je 0x3e248
leaq 0x29dcb(%rip), %rsi # 0x67ffd
leaq 0x29dda(%rip), %rdx # 0x68013
movl $0x3, %edi
movq %r14, %rcx
xorl %eax, %eax
callq 0x3e3c7
leaq 0x28251(%rip), %rdi # 0x664a0
leaq 0x2826a(%rip), %rsi # 0x664c0
xorl %edx, %edx
callq 0x3e4b3
testb %al, %al
je 0x3e299
leaq 0x28258(%rip), %rdi # 0x664c0
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x3e8f3
leal 0x1(%rax), %ebp
leaq 0x28224(%rip), %rdi # 0x664a0
callq 0x10600
leaq 0x29d97(%rip), %rsi # 0x6801f
movl $0x3, %edi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3e3c7
cmpb $0x1, 0x4c5dd(%rip) # 0x8a87d
jne 0x3e2bf
movq 0x40(%rbx), %rax
movl 0x21c(%rax), %edx
leaq 0x29d90(%rip), %rsi # 0x68043
movl $0x3, %edi
xorl %eax, %eax
callq 0x3e3c7
leaq 0x29db2(%rip), %rsi # 0x68078
xorl %ebp, %ebp
movl $0x2, %edi
xorl %eax, %eax
callq 0x3e3c7
movq 0x40(%rbx), %rdi
callq 0x37bfe
leaq 0x2a8a7(%rip), %rdx # 0x68b8b
leaq 0x29dbe(%rip), %rcx # 0x680a9
movq %rsp, %rdi
movl %eax, %esi
callq 0x3eb0c
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rcx
cmpq %rcx, %rax
je 0x3e320
xorl %ebp, %ebp
movq (%rax), %rdx
movzbl 0x70(%rdx), %edx
addl %edx, %ebp
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x3e30e
movq (%rsp), %rbx
leaq 0x2af65(%rip), %rdx # 0x69290
leaq 0x2af69(%rip), %rcx # 0x6929b
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
callq 0x3eb0c
leaq 0x30(%rsp), %r14
movq -0x10(%r14), %rdx
leaq 0x29d38(%rip), %rdi # 0x68086
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10070
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x3e36e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3e389
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x4bbf8(%rip), %rax # 0x89f88
movq (%rax), %rdi
callq 0x105a0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3e3bf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/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 0x3ecca
pushq %rax
movq %rsi, %rdi
callq 0x3eccb
movq 0x4b2c7(%rip), %rax # 0x89f88
movq (%rax), %rdi
popq %rax
jmp 0x105a0
retq
| /ckerr[P]buffy/extern/googletest/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %r14
movq %r14, %rdi
callq 0x3c030
testb %al, %al
jne 0x3ed3f
movq %r14, %rdi
callq 0x3c06c
testb %al, %al
je 0x3ed62
movq %r14, %rdi
callq 0x3c030
testb %al, %al
je 0x3ed54
leaq 0x29395(%rip), %rsi # 0x680e7
jmp 0x3ed69
leaq 0x2939a(%rip), %rsi # 0x680f5
movl $0x1, %edi
jmp 0x3ed6e
leaq 0x29370(%rip), %rsi # 0x680d9
movl $0x2, %edi
xorl %eax, %eax
callq 0x3e3c7
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x293b8(%rip), %rdi # 0x6813b
xorl %eax, %eax
callq 0x10070
movq %r14, %rdi
callq 0x3c06c
testb %al, %al
je 0x3ed9e
movq %rbx, %rdi
callq 0x3ee0f
cmpb $0x1, 0x4bacc(%rip) # 0x8a871
jne 0x3edee
movq 0x108(%rbx), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x56288
movq (%rbx), %rsi
leaq 0x29338(%rip), %rdi # 0x68103
xorl %eax, %eax
callq 0x10070
movq (%rbx), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3edf8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x3edf8
movl $0xa, %edi
callq 0x106f0
movq 0x4b189(%rip), %rax # 0x89f88
movq (%rax), %rdi
callq 0x105a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /ckerr[P]buffy/extern/googletest/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpb $0x1, 0x4b9bb(%rip) # 0x8a871
jne 0x3ef8b
movq %rsi, %rbx
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x3eee0
movq (%rax), %rdx
movzbl 0x80(%rdx), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x3eec9
leaq 0x29ca4(%rip), %rdx # 0x68b8b
leaq 0x291bb(%rip), %rcx # 0x680a9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3eb0c
leaq 0x29199(%rip), %rsi # 0x6809b
movl $0x2, %edi
xorl %eax, %eax
callq 0x3e3c7
movq (%r14), %r14
movq 0x8(%rbx), %r15
movq 0x80(%rbx), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x56288
leaq 0x40(%rsp), %rbx
movq -0x10(%rbx), %rcx
leaq 0x291cf(%rip), %rdi # 0x6810d
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10070
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x3ef61
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x4b020(%rip), %rax # 0x89f88
movq (%rax), %rdi
callq 0x105a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ef8b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3efb3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x40(%rdi), %rdi
callq 0x37924
movl %eax, %ebx
leaq 0x290e6(%rip), %rsi # 0x680f5
movl $0x1, %edi
xorl %eax, %eax
callq 0x3e3c7
leaq 0x29b69(%rip), %rdx # 0x68b8b
leaq 0x29080(%rip), %rcx # 0x680a9
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl %ebx, 0x4(%rsp)
movl %ebx, %esi
callq 0x3eb0c
movq (%r15), %rsi
leaq 0x290e2(%rip), %rdi # 0x68128
xorl %eax, %eax
callq 0x10070
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3f067
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x40(%r14), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0x3f1b6
leaq 0x290ac(%rip), %r12 # 0x6813b
xorl %ebx, %ebx
movq 0xd0(%rcx), %rdx
movq 0xd8(%rcx), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbx
jge 0x3f0ba
cmpl $0x0, (%rdx,%rbx,4)
js 0x3f0ba
movq (%rax,%rbx,8), %r13
jmp 0x3f0bd
xorl %r13d, %r13d
cmpb $0x1, 0x70(%r13)
jne 0x3f18e
movq %r13, %rdi
callq 0x37974
testl %eax, %eax
je 0x3f18e
movq 0x30(%r13), %rax
movq 0x38(%r13), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x3f18e
xorl %r15d, %r15d
movq 0x48(%r13), %rcx
movq 0x50(%r13), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %rsi, %r15
jge 0x3f112
movl (%rcx,%r15,4), %edx
testl %edx, %edx
js 0x3f11e
movl %edx, %ecx
movq (%rax,%rcx,8), %rbp
jmp 0x3f120
xorl %ebp, %ebp
cmpb $0x1, 0x80(%rbp)
jne 0x3f170
leaq 0x90(%rbp), %rdi
callq 0x3c06c
testb %al, %al
je 0x3f170
movl $0x1, %edi
leaq 0x28fb0(%rip), %rsi # 0x680f5
xorl %eax, %eax
callq 0x3e3c7
movq 0x8(%r13), %rsi
movq 0x20(%rbp), %rdx
movq %r12, %rdi
xorl %eax, %eax
callq 0x10070
movq %rbp, %rdi
callq 0x3ee0f
movl $0xa, %edi
callq 0x106f0
incq %r15
movq 0x30(%r13), %rax
movq 0x38(%r13), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r15
jl 0x3f0f2
incq %rbx
movq 0x40(%r14), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %rbx
jl 0x3f091
movl 0x4(%rsp), %esi
cmpl $0x1, %esi
leaq 0x28f8d(%rip), %rax # 0x68151
leaq 0x28f8b(%rip), %rdx # 0x68156
cmoveq %rax, %rdx
leaq 0x28f6b(%rip), %rdi # 0x68141
xorl %eax, %eax
callq 0x10070
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /ckerr[P]buffy/extern/googletest/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 0x3f243
movq 0x40(%rdi), %rax
movq 0xd0(%rax), %rcx
movq 0xd8(%rax), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x3f243
movl %esi, %edx
cmpl $0x0, (%rcx,%rdx,4)
js 0x3f243
movq 0xb8(%rax), %rax
movq (%rax,%rdx,8), %rax
retq
xorl %eax, %eax
retq
| /ckerr[P]buffy/extern/googletest/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0x3788a
testl %eax, %eax
je 0x3f4ce
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0x3f4ce
leaq 0x28d96(%rip), %r15 # 0x6813b
xorl %r13d, %r13d
movq 0xd0(%rcx), %rdx
movq 0xd8(%rcx), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r13
jge 0x3f3d2
cmpl $0x0, (%rdx,%r13,4)
js 0x3f3d2
movq (%rax,%r13,8), %r12
jmp 0x3f3d5
xorl %r12d, %r12d
cmpb $0x1, 0x70(%r12)
jne 0x3f4a6
movq %r12, %rdi
callq 0x378da
testl %eax, %eax
je 0x3f4a6
movq 0x30(%r12), %rax
movq 0x38(%r12), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x3f4a6
xorl %ebp, %ebp
movq 0x48(%r12), %rcx
movq 0x50(%r12), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %rsi, %rbp
jge 0x3f42d
movl (%rcx,%rbp,4), %edx
testl %edx, %edx
js 0x3f439
movl %edx, %ecx
movq (%rax,%rcx,8), %r14
jmp 0x3f43c
xorl %r14d, %r14d
cmpb $0x1, 0x80(%r14)
jne 0x3f486
leaq 0x90(%r14), %rdi
callq 0x3c030
testb %al, %al
je 0x3f486
movl $0x2, %edi
leaq 0x28c85(%rip), %rsi # 0x680e7
xorl %eax, %eax
callq 0x3e3c7
movq 0x8(%r12), %rsi
movq 0x20(%r14), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x10070
movl $0xa, %edi
callq 0x106f0
incq %rbp
movq 0x30(%r12), %rax
movq 0x38(%r12), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbp
jl 0x3f40c
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 0x3f3a8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /ckerr[P]buffy/extern/googletest/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x28b7c(%rip), %rsi # 0x68078
xorl %ebp, %ebp
movl $0x2, %edi
xorl %eax, %eax
callq 0x3e3c7
movq 0x40(%rbx), %rdi
callq 0x37bfe
leaq 0x29671(%rip), %rdx # 0x68b8b
leaq 0x28b88(%rip), %rcx # 0x680a9
leaq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x3eb0c
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rcx
cmpq %rcx, %rax
je 0x3f558
xorl %ebp, %ebp
movq (%rax), %rdx
movzbl 0x70(%rdx), %edx
addl %edx, %ebp
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x3f546
movq 0x8(%rsp), %r14
leaq 0x29d2c(%rip), %rdx # 0x69290
leaq 0x29d30(%rip), %rcx # 0x6929b
leaq 0x28(%rsp), %rdi
movl %ebp, %esi
callq 0x3eb0c
leaq 0x38(%rsp), %r15
movq -0x10(%r15), %rdx
leaq 0x28c20(%rip), %rdi # 0x681a7
movq %r14, %rsi
xorl %eax, %eax
callq 0x10070
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x3f5a7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x18(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x3f5c2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
cmpb $0x1, 0x4b2a8(%rip) # 0x8a871
jne 0x3f611
movq 0x40(%rbx), %rax
movq 0x230(%rax), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x56288
movq (%r14), %rsi
leaq 0x28bc2(%rip), %rdi # 0x681b7
xorl %eax, %eax
callq 0x10070
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x3f611
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movl $0xa, %edi
callq 0x106f0
leaq 0x28ba4(%rip), %rsi # 0x681c6
movl $0x2, %edi
xorl %eax, %eax
callq 0x3e3c7
movq 0x40(%rbx), %rdi
callq 0x37804
leaq 0x2954d(%rip), %rdx # 0x68b8b
leaq 0x28a64(%rip), %rcx # 0x680a9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x3eb0c
movq (%r14), %rsi
leaq 0x289e0(%rip), %rdi # 0x6803e
xorl %eax, %eax
callq 0x10070
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x3f67a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x40(%rbx), %rdi
callq 0x3788a
testl %eax, %eax
jle 0x3f6e7
movl %eax, %ebp
leaq 0x28a57(%rip), %rsi # 0x680e7
movl $0x2, %edi
xorl %eax, %eax
callq 0x3e3c7
leaq 0x294e8(%rip), %rdx # 0x68b8b
leaq 0x289ff(%rip), %rcx # 0x680a9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x3eb0c
movq (%r14), %rsi
leaq 0x28a65(%rip), %rdi # 0x68128
xorl %eax, %eax
callq 0x10070
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x3f6df
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x3f35e
movq 0x40(%rbx), %rdi
callq 0x563ba
testb %al, %al
jne 0x3f704
movq %rbx, %rdi
callq 0x3efec
movq %rbx, %rdi
callq 0x3f246
movq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x379be
testl %eax, %eax
je 0x3f75f
cmpb $0x0, 0x4b0e8(%rip) # 0x8a803
jne 0x3f75f
movl %eax, %ebx
movq %r14, %rdi
callq 0x563ba
testb %al, %al
je 0x3f735
movl $0xa, %edi
callq 0x106f0
cmpl $0x1, %ebx
leaq 0x28a12(%rip), %rax # 0x68151
leaq 0x28a10(%rip), %rcx # 0x68156
cmoveq %rax, %rcx
leaq 0x28a83(%rip), %rsi # 0x681d4
movl $0x3, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x3e3c7
movq 0x4a822(%rip), %rax # 0x89f88
movq (%rax), %rdi
callq 0x105a0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f797
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/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 0x3f7e8
pushq %rax
movq %rsi, %rdi
callq 0x3eccb
movq 0x4a7a9(%rip), %rax # 0x89f88
movq (%rax), %rdi
popq %rax
jmp 0x105a0
retq
nop
| /ckerr[P]buffy/extern/googletest/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x287bc(%rip), %rsi # 0x68078
xorl %ebp, %ebp
movl $0x2, %edi
xorl %eax, %eax
callq 0x3e3c7
movq 0x40(%rbx), %rdi
callq 0x37bfe
leaq 0x292b1(%rip), %rdx # 0x68b8b
leaq 0x287c8(%rip), %rcx # 0x680a9
leaq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x3eb0c
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rcx
cmpq %rcx, %rax
je 0x3f918
xorl %ebp, %ebp
movq (%rax), %rdx
movzbl 0x70(%rdx), %edx
addl %edx, %ebp
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x3f906
movq 0x8(%rsp), %r14
leaq 0x2996c(%rip), %rdx # 0x69290
leaq 0x29970(%rip), %rcx # 0x6929b
leaq 0x28(%rsp), %rdi
movl %ebp, %esi
callq 0x3eb0c
leaq 0x38(%rsp), %r15
movq -0x10(%r15), %rdx
leaq 0x28860(%rip), %rdi # 0x681a7
movq %r14, %rsi
xorl %eax, %eax
callq 0x10070
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x3f967
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x18(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x3f982
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
cmpb $0x1, 0x4aee8(%rip) # 0x8a871
jne 0x3f9d1
movq 0x40(%rbx), %rax
movq 0x230(%rax), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x56288
movq (%r14), %rsi
leaq 0x28802(%rip), %rdi # 0x681b7
xorl %eax, %eax
callq 0x10070
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x3f9d1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movl $0xa, %edi
callq 0x106f0
leaq 0x287e4(%rip), %rsi # 0x681c6
movl $0x2, %edi
xorl %eax, %eax
callq 0x3e3c7
movq 0x40(%rbx), %rdi
callq 0x37804
leaq 0x2918d(%rip), %rdx # 0x68b8b
leaq 0x286a4(%rip), %rcx # 0x680a9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x3eb0c
movq (%r14), %rsi
leaq 0x28620(%rip), %rdi # 0x6803e
xorl %eax, %eax
callq 0x10070
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x3fa3a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x40(%rbx), %rdi
callq 0x3788a
testl %eax, %eax
jle 0x3fa9f
movl %eax, %ebp
leaq 0x28697(%rip), %rsi # 0x680e7
movl $0x2, %edi
xorl %eax, %eax
callq 0x3e3c7
leaq 0x29128(%rip), %rdx # 0x68b8b
leaq 0x2863f(%rip), %rcx # 0x680a9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x3eb0c
movq (%r14), %rsi
leaq 0x285bb(%rip), %rdi # 0x6803e
xorl %eax, %eax
callq 0x10070
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x3fa9f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x379be
testl %eax, %eax
je 0x3fafa
cmpb $0x0, 0x4ad4d(%rip) # 0x8a803
jne 0x3fafa
movl %eax, %ebx
movq %r14, %rdi
callq 0x563ba
testb %al, %al
je 0x3fad0
movl $0xa, %edi
callq 0x106f0
cmpl $0x1, %ebx
leaq 0x28677(%rip), %rax # 0x68151
leaq 0x28675(%rip), %rcx # 0x68156
cmoveq %rax, %rcx
leaq 0x286e8(%rip), %rsi # 0x681d4
movl $0x3, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x3e3c7
movq 0x4a487(%rip), %rax # 0x89f88
movq (%rax), %rdi
callq 0x105a0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3fb32
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/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 0x40048
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x18(%rdi), %r12
subq 0x10(%rdi), %r12
je 0x4003d
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 0x40024
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /ckerr[P]buffy/extern/googletest/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x48e48(%rip), %rax # 0x88ea0
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x3(%rsp), %rdx
callq 0x5424e
cmpq $0x0, 0x10(%rbx)
jne 0x400ad
leaq 0x274ad(%rip), %rdx # 0x67524
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0xf78, %ecx # imm = 0xF78
callq 0x515a8
movq 0x49f56(%rip), %rdi # 0x89fe8
leaq 0x28157(%rip), %rsi # 0x681f0
movl $0x1f, %edx
callq 0x10560
leaq 0x4(%rsp), %rdi
callq 0x516ea
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x4(%rsp), %rdi
callq 0x516ea
jmp 0x400c7
movq %rax, %r14
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x400df
movq (%rbx), %rsi
incq %rsi
callq 0x10490
movq %r14, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/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 %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x401a8
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x10310
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x402f4
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x380ed
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x10540
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x4014c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x10460
movq 0x49e35(%rip), %rsi # 0x89f90
leaq 0x20(%rsp), %rdi
callq 0x10360
leaq 0xa0(%rsp), %rdi
callq 0x10140
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x4017f
movq %rax, %rbx
movq 0x49e07(%rip), %rsi # 0x89f90
leaq 0x20(%rsp), %rdi
callq 0x10360
leaq 0xa0(%rsp), %rdi
callq 0x10140
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::ListTestsMatchingFilter(std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
const std::vector<TestSuite*>& test_suites) {
FILE* xmlout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintXmlTestsList(&stream, test_suites);
fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
fclose(xmlout);
} | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x401a8
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x10310
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x409dc
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x380ed
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x10540
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x40980
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x10460
movq 0x49601(%rip), %rsi # 0x89f90
leaq 0x20(%rsp), %rdi
callq 0x10360
leaq 0xa0(%rsp), %rdi
callq 0x10140
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x409b3
movq %rax, %rbx
movq 0x495d3(%rip), %rsi # 0x89f90
leaq 0x20(%rsp), %rdi
callq 0x10360
leaq 0xa0(%rsp), %rdi
callq 0x10140
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::EscapeXml(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::string XmlUnitTestResultPrinter::EscapeXml(
const std::string& str, bool is_attribute) {
Message m;
for (size_t i = 0; i < str.size(); ++i) {
const char ch = str[i];
switch (ch) {
case '<':
m << "<";
break;
case '>':
m << ">";
break;
case '&':
m << "&";
break;
case '\'':
if (is_attribute)
m << "'";
else
m << '\'';
break;
case '"':
if (is_attribute)
m << """;
else
m << '"';
break;
default:
if (IsValidXmlCharacter(ch)) {
if (is_attribute && IsNormalizableWhitespace(ch))
m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
<< ";";
else
m << ch;
}
break;
}
}
return m.GetString();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x37e78
cmpq $0x0, 0x8(%r14)
je 0x40e2f
movq 0x8(%rsp), %r15
addq $0x10, %r15
xorl %ebx, %ebx
leaq 0x10(%rsp), %r12
movq (%r14), %rax
movb (%rax,%rbx), %al
movzbl %al, %r13d
cmpl $0x26, %r13d
jle 0x40ced
cmpl $0x27, %r13d
je 0x40d07
movl $0x4, %edx
cmpl $0x3e, %r13d
je 0x40d2f
cmpl $0x3c, %r13d
jne 0x40d67
leaq 0x27525(%rip), %rsi # 0x68210
jmp 0x40d4d
cmpl $0x22, %r13d
je 0x40d38
cmpl $0x26, %r13d
jne 0x40d67
movl $0x5, %edx
leaq 0x27515(%rip), %rsi # 0x6821a
jmp 0x40d4d
movl $0x6, %edx
leaq 0x2750d(%rip), %rsi # 0x68220
testb %bpl, %bpl
jne 0x40d4d
movb $0x27, 0x10(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x10560
jmp 0x40d55
leaq 0x274df(%rip), %rsi # 0x68215
jmp 0x40d4d
movl $0x6, %edx
leaq 0x274e3(%rip), %rsi # 0x68227
testb %bpl, %bpl
je 0x40e15
movq %r15, %rdi
callq 0x10560
incq %rbx
cmpq 0x8(%r14), %rbx
jb 0x40cb9
jmp 0x40e2f
cmpb $0x1f, %al
jg 0x40d7c
cmpl $0xd, %r13d
ja 0x40d55
movl $0x2600, %ecx # imm = 0x2600
btl %r13d, %ecx
jae 0x40d55
testb %bpl, %bpl
je 0x40dfc
cmpl $0xd, %r13d
ja 0x40dfc
movl $0x2600, %ecx # imm = 0x2600
btl %r13d, %ecx
jae 0x40dfc
movl $0x3, %edx
movq %r15, %rdi
leaq 0x2748d(%rip), %rsi # 0x6822e
callq 0x10560
movq %r12, %rdi
movl %r13d, %esi
callq 0x3b800
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r15, %rdi
callq 0x10560
movl $0x1, %edx
movq %r15, %rdi
leaq 0x268ab(%rip), %rsi # 0x6767d
callq 0x10560
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x40d55
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x40d55
movb %al, 0x10(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x10560
jmp 0x40d55
movb $0x22, 0x10(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x10560
jmp 0x40d55
movq 0x8(%rsp), %r14
movq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x380ed
testq %r14, %r14
je 0x40e52
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x40e8d
jmp 0x40e8d
jmp 0x40e8d
jmp 0x40e8d
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x40e90
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x40e90
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x40ea0
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
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 0x554f4
cmpq $0x0, 0x8(%r14)
je 0x40f0f
movq (%r14), %r12
movl $0x2600, %ebp # imm = 0x2600
movb (%r12), %al
cmpb $0x1f, %al
jg 0x40ef5
cmpb $0xd, %al
ja 0x40f00
movzbl %al, %ecx
btl %ecx, %ebp
jae 0x40f00
movsbl %al, %esi
movq %rbx, %rdi
callq 0x562f2
incq %r12
movq (%r14), %rax
addq 0x8(%r14), %rax
cmpq %rax, %r12
jne 0x40ee1
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x40f1d
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x40f33
movq (%r15), %rsi
incq %rsi
callq 0x10490
movq %r14, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x26482(%rip), %rsi # 0x683e3
movq %r14, %rdi
callq 0x328de
testl %eax, %eax
je 0x42017
leaq 0x26448(%rip), %rsi # 0x683c0
movq %r14, %rdi
callq 0x328de
testl %eax, %eax
je 0x4202c
leaq 0x26351(%rip), %rsi # 0x682e0
movq %r14, %rdi
callq 0x328de
testl %eax, %eax
je 0x42041
leaq 0x2557e(%rip), %rdx # 0x67524
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x909, %ecx # imm = 0x909
callq 0x515a8
movq 0x48027(%rip), %rdi # 0x89fe8
leaq 0x27178(%rip), %rsi # 0x69140
movl $0x18, %edx
callq 0x10560
movq 0x4800f(%rip), %rdi # 0x89fe8
leaq 0x27179(%rip), %rsi # 0x69159
movl $0x23, %edx
callq 0x10560
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x47ff0(%rip), %rdi # 0x89fe8
callq 0x10560
leaq 0x4(%rsp), %rdi
callq 0x516ea
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x4205c
leaq 0x47462(%rip), %rsi # 0x89480
leaq 0x4749b(%rip), %rdx # 0x894c0
leaq 0x1(%rsp), %rcx
jmp 0x42054
leaq 0x4748d(%rip), %rsi # 0x894c0
leaq 0x474c6(%rip), %rdx # 0x89500
leaq 0x2(%rsp), %rcx
jmp 0x42054
leaq 0x474f8(%rip), %rsi # 0x89540
leaq 0x47541(%rip), %rdx # 0x89590
leaq 0x3(%rsp), %rcx
movq %rbx, %rdi
callq 0x58cb2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x516ea
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/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);
int failures = 0;
int skips = 0;
for (int i = 0; i < result.total_part_count(); ++i) {
const TestPartResult& part = result.GetTestPartResult(i);
if (part.failed()) {
if (++failures == 1 && skips == 0) {
*stream << ">\n";
}
const std::string location =
internal::FormatCompilerIndependentFileLocation(part.file_name(),
part.line_number());
const std::string summary = location + "\n" + part.summary();
*stream << " <failure message=\""
<< EscapeXmlAttribute(summary)
<< "\" type=\"\">";
const std::string detail = location + "\n" + part.message();
OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
*stream << "</failure>\n";
} else if (part.skipped()) {
if (++skips == 1 && failures == 0) {
*stream << ">\n";
}
const std::string location =
internal::FormatCompilerIndependentFileLocation(part.file_name(),
part.line_number());
const std::string summary = location + "\n" + part.summary();
*stream << " <skipped message=\""
<< EscapeXmlAttribute(summary.c_str()) << "\">";
const std::string detail = location + "\n" + part.message();
OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
*stream << "</skipped>\n";
}
}
if (failures == 0 && skips == 0 && result.test_property_count() == 0) {
*stream << " />\n";
} else {
if (failures == 0 && skips == 0) {
*stream << ">\n";
}
OutputXmlTestProperties(stream, result);
*stream << " </testcase>\n";
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xa8(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x26237(%rip), %rsi # 0x682e0
leaq 0x26238(%rip), %rdx # 0x682e8
leaq 0x98(%rsp), %rdi
callq 0x2e262
movq %r15, 0x60(%rsp)
cmpb $0x0, 0x83(%r15)
jne 0x42cbd
leaq 0x26204(%rip), %rsi # 0x682db
movl $0xd, %edx
movq %rbx, %rdi
callq 0x10560
leaq 0x30(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x26261(%rip), %rsi # 0x68355
leaq 0x2625e(%rip), %rdx # 0x68359
leaq 0x20(%rsp), %rdi
callq 0x2e262
movq 0x60(%rsp), %rax
movq 0x20(%rax), %rsi
movq %rsp, %rdi
leaq 0x40(%rsp), %rdx
callq 0x5424e
leaq 0x98(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x41d7c
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x4214e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x42165
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x60(%rsp), %rax
movq 0x48(%rax), %rax
testq %rax, %rax
je 0x42203
cmpq $0x0, (%rax)
je 0x42203
leaq 0x20(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x26159(%rip), %rsi # 0x682e9
leaq 0x2615d(%rip), %rdx # 0x682f4
callq 0x2e262
movq 0x60(%rsp), %rax
movq 0x48(%rax), %rax
testq %rax, %rax
je 0x421af
movq (%rax), %rsi
jmp 0x421b1
xorl %esi, %esi
movq %rsp, %rdi
leaq 0x40(%rsp), %rdx
callq 0x5424e
leaq 0x98(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x41d7c
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x421ec
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x42203
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x60(%rsp), %rax
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x422a1
cmpq $0x0, (%rax)
je 0x422a1
leaq 0x20(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x260c7(%rip), %rsi # 0x682f5
leaq 0x260ca(%rip), %rdx # 0x682ff
callq 0x2e262
movq 0x60(%rsp), %rax
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x4224d
movq (%rax), %rsi
jmp 0x4224f
xorl %esi, %esi
movq %rsp, %rdi
leaq 0x40(%rsp), %rdx
callq 0x5424e
leaq 0x98(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x41d7c
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4228a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x422a1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
cmpb $0x1, 0x485a1(%rip) # 0x8a849
jne 0x423b4
leaq 0x20(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x26043(%rip), %rsi # 0x68300
leaq 0x26040(%rip), %rdx # 0x68304
callq 0x2e262
movq 0x60(%rsp), %rax
movq 0x50(%rax), %rsi
movq %rsp, %rdi
leaq 0x40(%rsp), %rdx
callq 0x5424e
leaq 0x98(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x41d7c
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4230d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x42324
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x20(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x25fd2(%rip), %rsi # 0x68305
leaq 0x25fcf(%rip), %rdx # 0x68309
callq 0x2e262
movq 0x60(%rsp), %rax
movl 0x70(%rax), %eax
leaq 0x40(%rsp), %rsi
movl %eax, (%rsi)
movq %rsp, %rdi
callq 0x56350
leaq 0x98(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x41d7c
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x42384
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4239b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x25f68(%rip), %rsi # 0x6830a
movl $0x4, %edx
movq %rbx, %rdi
callq 0x10560
jmp 0x42cbd
leaq 0x20(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x25f4c(%rip), %rsi # 0x6830f
leaq 0x25f4b(%rip), %rdx # 0x68315
callq 0x2e262
movq 0x60(%rsp), %rax
movzbl 0x80(%rax), %eax
leaq 0x25f37(%rip), %rcx # 0x68319
leaq 0x25f2d(%rip), %rsi # 0x68316
testq %rax, %rax
cmovneq %rcx, %rsi
movq %rsp, %rdi
movq %r15, (%rdi)
xorq $0x1, %rax
leaq (%rax,%rax,2), %rax
leaq (%rsi,%rax), %rdx
addq $0x3, %rdx
callq 0x2e262
leaq 0x98(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x41d7c
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x42439
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x42450
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x20(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x25ebe(%rip), %rsi # 0x6831d
leaq 0x25ebd(%rip), %rdx # 0x68323
callq 0x2e262
movq 0x60(%rsp), %rax
leaq 0x90(%rax), %rdi
cmpb $0x1, 0x80(%rax)
movq %rdi, 0x90(%rsp)
jne 0x424a3
callq 0x3c030
leaq 0x25e90(%rip), %rcx # 0x68324
leaq 0x25e91(%rip), %r15 # 0x6832c
testb %al, %al
cmovneq %rcx, %r15
jmp 0x424aa
leaq 0x25e8c(%rip), %r15 # 0x68336
movq %rsp, %r13
leaq 0x10(%rsp), %rax
movq %rax, (%r13)
movq %r15, %rdi
callq 0x101b0
leaq (%rax,%r15), %rdx
movq %r13, %rdi
movq %r15, %rsi
callq 0x2e262
leaq 0x98(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x41d7c
movq (%rsp), %rdi
leaq 0x10(%rsp), %r15
cmpq %r15, %rdi
je 0x42500
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x42517
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x20(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x25e1b(%rip), %rsi # 0x68341
leaq 0x25e18(%rip), %rdx # 0x68345
callq 0x2e262
movq 0x60(%rsp), %rax
movq 0x108(%rax), %rsi
movq %rsp, %rdi
callq 0x40f3b
leaq 0x98(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x41d7c
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x42574
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4258b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x20(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x25dac(%rip), %rsi # 0x68346
leaq 0x25dae(%rip), %rdx # 0x6834f
callq 0x2e262
movq 0x60(%rsp), %rax
movq 0x100(%rax), %rsi
movq %rsp, %rdi
callq 0x40fc8
leaq 0x98(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x41d7c
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x425e8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x425ff
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x20(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x25d42(%rip), %rsi # 0x68350
leaq 0x25d44(%rip), %rdx # 0x68359
callq 0x2e262
movq %rsp, %rdi
leaq 0x40(%rsp), %rdx
movq %r12, %rsi
callq 0x5424e
leaq 0x98(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x41d7c
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x42658
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
movq 0x90(%rsp), %r15
je 0x42677
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x60(%rsp), %rcx
movq 0xd0(%rcx), %rax
subq 0xc8(%rcx), %rax
shrq $0x4, %rax
imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7
testl %eax, %eax
jle 0x42c61
xorl %ebp, %ebp
leaq 0x40(%rsp), %r12
leaq 0x68(%rsp), %r13
movl $0x0, 0x88(%rsp)
xorl %r14d, %r14d
movq %r15, %rdi
movl %ebp, %esi
callq 0x3b940
movq %rax, %r15
movl (%rax), %eax
leal -0x1(%rax), %ecx
cmpl $0x1, %ecx
ja 0x42773
movl %r14d, %eax
orl 0x88(%rsp), %eax
jne 0x426f1
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x25c20(%rip), %rsi # 0x6830c
callq 0x10560
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x426fe
movq 0x8(%r15), %rsi
movl 0x28(%r15), %edx
leaq 0x20(%rsp), %rdi
callq 0x42ee5
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x3078a
movq %r12, %rdi
leaq 0x259f1(%rip), %rsi # 0x68126
callq 0x2e96e
movq 0x30(%r15), %rsi
movq %r12, %rdi
callq 0x2e96e
leaq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4282b
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x42831
cmpl $0x3, %eax
jne 0x4281e
movl 0x88(%rsp), %eax
orl %r14d, %eax
jne 0x4279c
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x25b75(%rip), %rsi # 0x6830c
callq 0x10560
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x427a9
movq 0x8(%r15), %rsi
movl 0x28(%r15), %edx
leaq 0x20(%rsp), %rdi
callq 0x42ee5
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x3078a
movq %r12, %rdi
leaq 0x25946(%rip), %rsi # 0x68126
callq 0x2e96e
movq 0x30(%r15), %rsi
movq %r12, %rdi
callq 0x2e96e
leaq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x42a12
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x42a18
movq 0x90(%rsp), %r15
jmp 0x42c28
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x42865
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x10490
movl $0x18, %edx
movq %rbx, %rdi
leaq 0x25ae6(%rip), %rsi # 0x6835a
callq 0x10560
movq %r12, %rdi
movq %rsp, %rsi
movl $0x1, %edx
callq 0x40c7c
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
movl $0xa, %edx
movq %rax, %rdi
leaq 0x25ac9(%rip), %rsi # 0x68373
callq 0x10560
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x428cb
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x3078a
movq %r13, %rdi
leaq 0x25832(%rip), %rsi # 0x68126
callq 0x2e96e
movq 0x50(%r15), %rsi
movq %r13, %rdi
callq 0x2e96e
leaq 0x50(%rsp), %rsi
movq %rsi, 0x40(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
movq 0x90(%rsp), %r15
je 0x42935
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
jmp 0x4293b
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x48(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x4296f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
movq %r13, %rdi
movq %r12, %rsi
callq 0x40ea8
movq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x41cbe
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x429a3
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
movl $0xb, %edx
movq %rbx, %rdi
leaq 0x259cc(%rip), %rsi # 0x6837e
callq 0x10560
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x429d3
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x10490
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x429ee
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x42a0a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
incl %r14d
jmp 0x42c28
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x42a4c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x10490
movl $0x18, %edx
movq %rbx, %rdi
leaq 0x2592f(%rip), %rsi # 0x6838a
callq 0x10560
movq (%rsp), %rsi
movq %r13, %rdi
leaq 0x8f(%rsp), %rdx
callq 0x5424e
movq %r12, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x40c7c
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
movl $0x2, %edx
movq %rax, %rdi
leaq 0x258d6(%rip), %rsi # 0x6837b
callq 0x10560
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x42ac6
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x42ae2
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x3078a
movq %r13, %rdi
leaq 0x2561b(%rip), %rsi # 0x68126
callq 0x2e96e
movq 0x50(%r15), %rsi
movq %r13, %rdi
callq 0x2e96e
leaq 0x50(%rsp), %rsi
movq %rsi, 0x40(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
movq 0x90(%rsp), %r15
je 0x42b4c
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
jmp 0x42b52
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x48(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x42b86
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
movq %r13, %rdi
movq %r12, %rsi
callq 0x40ea8
movq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x41cbe
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x42bba
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
movl $0xb, %edx
movq %rbx, %rdi
leaq 0x257da(%rip), %rsi # 0x683a3
callq 0x10560
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x42bea
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x10490
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x42c05
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x42c21
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
incl 0x88(%rsp)
movq 0x60(%rsp), %rcx
movq 0xd0(%rcx), %rax
subq 0xc8(%rcx), %rax
incl %ebp
shrq $0x4, %rax
imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7
cmpl %eax, %ebp
jl 0x426b6
orl 0x88(%rsp), %r14d
leaq 0xa8(%rsp), %r14
jne 0x42c90
movq 0x60(%rsp), %rcx
movq 0xe8(%rcx), %rax
subq 0xe0(%rcx), %rax
shrq $0x6, %rax
testl %eax, %eax
je 0x42ca9
leaq 0x25689(%rip), %rsi # 0x6830c
movl $0x2, %edx
movq %rbx, %rdi
callq 0x10560
movq %rbx, %rdi
movq %r15, %rsi
callq 0x430ee
movl $0x10, %edx
leaq 0x25708(%rip), %rsi # 0x683af
jmp 0x42cb5
movl $0x4, %edx
leaq 0x25655(%rip), %rsi # 0x6830a
movq %rbx, %rdi
callq 0x10560
movq 0x98(%rsp), %rdi
cmpq %r14, %rdi
je 0x42cda
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x10490
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x42d7d
jmp 0x42d41
jmp 0x42d7d
jmp 0x42d41
jmp 0x42eb5
jmp 0x42d7d
jmp 0x42eb5
jmp 0x42d41
jmp 0x42d7d
jmp 0x42eb5
jmp 0x42d41
jmp 0x42d7d
jmp 0x42eb5
jmp 0x42d41
jmp 0x42d7d
jmp 0x42eb5
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
jmp 0x42d69
jmp 0x42d41
jmp 0x42d7d
jmp 0x42d7d
jmp 0x42eb5
jmp 0x42eb5
jmp 0x42d41
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x42d6e
jmp 0x42d80
jmp 0x42d7d
jmp 0x42d7d
jmp 0x42eb5
jmp 0x42eb5
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42d80
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x42d80
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
jne 0x42ea6
jmp 0x42eb8
jmp 0x42eb5
jmp 0x42eb5
jmp 0x42eb5
jmp 0x42e22
jmp 0x42e40
jmp 0x42e1d
jmp 0x42e3b
jmp 0x42eb5
jmp 0x42e40
jmp 0x42e5d
jmp 0x42e3b
jmp 0x42ddb
jmp 0x42e3b
jmp 0x42e5d
jmp 0x42e22
jmp 0x42e40
jmp 0x42eb5
jmp 0x42e22
jmp 0x42e3b
jmp 0x42e3b
jmp 0x42e40
movq %rax, %rbx
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x42e60
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x42e60
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x42e43
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x42e43
movq %rax, %rbx
jmp 0x42e97
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x42e97
movq 0x50(%rsp), %rsi
jmp 0x42e8f
movq %rax, %rbx
jmp 0x42e7c
movq %rax, %rbx
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x42e7c
movq 0x78(%rsp), %rsi
jmp 0x42e74
jmp 0x42e5d
jmp 0x42e5d
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x42e7c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x10490
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x42e97
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x42eb8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x42eb8
movq %rax, %rbx
movq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rax
cmpq %rax, %rdi
je 0x42edd
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::FormatCompilerIndependentFileLocation[abi:cxx11](char const*, int) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
const char* file, int line) {
const std::string file_name(file == nullptr ? kUnknownFile : file);
if (line < 0)
return file_name;
else
return file_name + ":" + StreamableToString(line);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
testq %rsi, %rsi
leaq 0x236ae(%rip), %rax # 0x665b0
cmoveq %rax, %r14
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x101b0
leaq (%rax,%r14), %rdx
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x2e262
cmpl $0x0, 0xc(%rsp)
js 0x42fc5
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x3078a
leaq 0x2568a(%rip), %rsi # 0x685e4
leaq 0x10(%rsp), %rdi
callq 0x2e96e
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x56350
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x38(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r14, %rcx
je 0x42f95
movq 0x20(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x42fb4
leaq 0x40(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x42faf
movq 0x40(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x42fe6
movq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x2e9b4
jmp 0x42ff4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3078a
jmp 0x43067
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2ebfa
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x43013
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x43019
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 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43050
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x43067
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x4307e
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x430cb
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x430b2
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x430b2
jmp 0x430af
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x430ce
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x430ce
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x430e5
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest-port.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestProperties(std::ostream*, testing::TestResult const&) | void XmlUnitTestResultPrinter::OutputXmlTestProperties(
std::ostream* stream, const TestResult& result) {
const std::string kProperties = "properties";
const std::string kProperty = "property";
if (result.test_property_count() <= 0) {
return;
}
*stream << "<" << kProperties << ">\n";
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
*stream << "<" << kProperty;
*stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\"";
*stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\"";
*stream << "/>\n";
}
*stream << "</" << kProperties << ">\n";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2530a(%rip), %rsi # 0x6841f
leaq 0x2530d(%rip), %rdx # 0x68429
leaq 0x48(%rsp), %rdi
callq 0x2e262
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x252f4(%rip), %rsi # 0x6842a
leaq 0x252f5(%rip), %rdx # 0x68432
leaq 0x68(%rsp), %rdi
callq 0x2e262
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
testl %eax, %eax
jle 0x43371
leaq 0x2526a(%rip), %rsi # 0x683cc
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10560
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
leaq 0x25184(%rip), %rsi # 0x6830c
movl $0x2, %edx
movq %rax, %rdi
callq 0x10560
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
testl %eax, %eax
jle 0x43337
xorl %ebp, %ebp
leaq 0x28(%rsp), %r13
leaq 0x2532a(%rip), %r15 # 0x684e1
movq %r14, %rdi
movl %ebp, %esi
callq 0x3b9ae
movq %rax, %r12
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x251f9(%rip), %rsi # 0x683cc
callq 0x10560
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
movl $0x7, %edx
movq %rbx, %rdi
leaq 0x2523a(%rip), %rsi # 0x68433
callq 0x10560
movq (%r12), %rsi
movq %r13, %rdi
leaq 0x7(%rsp), %rdx
callq 0x5424e
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x40c7c
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x10560
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4325f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x4327b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movl $0x8, %edx
movq %rbx, %rdi
leaq 0x251b1(%rip), %rsi # 0x6843b
callq 0x10560
movq 0x20(%r12), %rsi
movq %r13, %rdi
leaq 0x7(%rsp), %rdx
callq 0x5424e
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x40c7c
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x10560
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x432f1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x4330d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movl $0x3, %edx
movq %rbx, %rdi
leaq 0x24fef(%rip), %rsi # 0x6830b
callq 0x10560
incl %ebp
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jl 0x431b7
leaq 0x250a2(%rip), %rsi # 0x683e0
movl $0x2, %edx
movq %rbx, %rdi
callq 0x10560
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
leaq 0x24fa8(%rip), %rsi # 0x6830c
movl $0x2, %edx
movq %rax, %rdi
callq 0x10560
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x4338d
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x433a9
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4342b
jmp 0x4340c
jmp 0x4340c
jmp 0x433c8
jmp 0x4340c
movq %rax, %rbx
jmp 0x433ee
jmp 0x433cf
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x433ee
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x4340f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x4340f
movq %rax, %rbx
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x4342b
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x43447
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream*, testing::TestSuite const&) | void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
const TestSuite& test_suite) {
const std::string kTestsuite = "testsuite";
*stream << " <" << kTestsuite;
OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());
OutputXmlAttribute(stream, kTestsuite, "tests",
StreamableToString(test_suite.reportable_test_count()));
if (!GTEST_FLAG(list_tests)) {
OutputXmlAttribute(stream, kTestsuite, "failures",
StreamableToString(test_suite.failed_test_count()));
OutputXmlAttribute(
stream, kTestsuite, "disabled",
StreamableToString(test_suite.reportable_disabled_test_count()));
OutputXmlAttribute(stream, kTestsuite, "skipped",
StreamableToString(test_suite.skipped_test_count()));
OutputXmlAttribute(stream, kTestsuite, "errors", "0");
OutputXmlAttribute(stream, kTestsuite, "time",
FormatTimeInMillisAsSeconds(test_suite.elapsed_time()));
OutputXmlAttribute(
stream, kTestsuite, "timestamp",
FormatEpochTimeInMillisAsIso8601(test_suite.start_timestamp()));
*stream << TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result());
}
*stream << ">\n";
for (int i = 0; i < test_suite.total_test_count(); ++i) {
if (test_suite.GetTestInfo(i)->is_reportable())
OutputXmlTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
}
*stream << " </" << kTestsuite << ">\n";
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x24f4d(%rip), %rsi # 0x683c0
leaq 0x24f4f(%rip), %rdx # 0x683c9
leaq 0x50(%rsp), %rdi
callq 0x2e262
leaq 0x24f3f(%rip), %rsi # 0x683ca
movl $0x3, %edx
movq %rbx, %rdi
callq 0x10560
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x24e9a(%rip), %rsi # 0x68355
leaq 0x24e97(%rip), %rdx # 0x68359
leaq 0x8(%rsp), %rdi
callq 0x2e262
movq 0x8(%r14), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x4c(%rsp), %rdx
callq 0x5424e
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x41d7c
leaq 0x38(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x43511
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x43528
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x24b72(%rip), %rsi # 0x680a9
leaq 0x24b70(%rip), %rdx # 0x680ae
callq 0x2e262
movq 0x30(%r14), %rax
movq 0x38(%r14), %rdx
cmpq %rdx, %rax
je 0x4357c
xorl %esi, %esi
xorl %ecx, %ecx
movq (%rax), %rdi
movzbl 0x83(%rdi), %r8d
xorl $0x1, %r8d
cmpb $0x0, 0x82(%rdi)
cmovel %esi, %r8d
addl %r8d, %ecx
addq $0x8, %rax
cmpq %rdx, %rax
jne 0x43554
jmp 0x4357e
xorl %ecx, %ecx
leaq 0x4c(%rsp), %rsi
movl %ecx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x56350
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x41d7c
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x435bd
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x435d4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
cmpb $0x0, 0x4726e(%rip) # 0x8a849
jne 0x43910
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x259d0(%rip), %rsi # 0x68fc0
leaq 0x259d1(%rip), %rdx # 0x68fc8
callq 0x2e262
movq %r14, %rdi
callq 0x37974
leaq 0x4c(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x56350
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x41d7c
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x43643
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4365a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x24d65(%rip), %rsi # 0x683ce
leaq 0x24d66(%rip), %rdx # 0x683d6
callq 0x2e262
movq 0x30(%r14), %rcx
movq 0x38(%r14), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x436ad
movq (%rcx), %rsi
cmpb $0x1, 0x82(%rsi)
movl $0x0, %edi
jne 0x436a5
testb $0x1, 0x83(%rsi)
jne 0x436a5
movzbl 0x81(%rsi), %edi
addl %edi, %eax
addq $0x8, %rcx
jmp 0x4367f
leaq 0x4c(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x56350
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x41d7c
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x436ec
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x43703
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x24c12(%rip), %rsi # 0x68324
leaq 0x24c12(%rip), %rdx # 0x6832b
callq 0x2e262
movq %r14, %rdi
callq 0x378da
leaq 0x4c(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x56350
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x41d7c
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x43765
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4377c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x24c4c(%rip), %rsi # 0x683d7
leaq 0x24c4b(%rip), %rdx # 0x683dd
callq 0x2e262
leaq 0x28(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x260d0(%rip), %rsi # 0x69876
leaq 0x260ca(%rip), %rdx # 0x69877
callq 0x2e262
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x41d7c
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x437e0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x437f7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x24b3b(%rip), %rsi # 0x68341
leaq 0x24b38(%rip), %rdx # 0x68345
callq 0x2e262
movq 0x80(%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x40f3b
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x41d7c
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x43851
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x43868
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x24acf(%rip), %rsi # 0x68346
leaq 0x24ad1(%rip), %rdx # 0x6834f
callq 0x2e262
movq 0x78(%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x40fc8
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x41d7c
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x438bf
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x438d6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x88(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x43aa8
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x43910
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x249f5(%rip), %rsi # 0x6830c
movl $0x2, %edx
movq %rbx, %rdi
callq 0x10560
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x439ac
xorl %r12d, %r12d
movq 0x48(%r14), %rcx
movq 0x50(%r14), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rdx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
cmpq %rdx, %r12
jge 0x4395a
movl (%rcx,%r12,4), %esi
movl %esi, %esi
movq (%rax,%rsi,8), %rsi
cmpb $0x1, 0x82(%rsi)
jne 0x43992
testb $0x1, 0x83(%rsi)
jne 0x43992
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
cmpq %rdx, %r12
jge 0x43980
movl (%rcx,%r12,4), %edi
movq 0x8(%r14), %rsi
movl %edi, %ecx
movq (%rax,%rcx,8), %rdx
movq %rbx, %rdi
callq 0x4207c
incq %r12
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jl 0x4393a
leaq 0x24a2b(%rip), %rsi # 0x683de
movl $0x4, %edx
movq %rbx, %rdi
callq 0x10560
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
leaq 0x24933(%rip), %rsi # 0x6830c
movl $0x2, %edx
movq %rax, %rdi
callq 0x10560
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x439fd
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x10490
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x43a66
jmp 0x43a86
jmp 0x43a33
jmp 0x43a66
jmp 0x43a86
jmp 0x43a33
jmp 0x43a66
jmp 0x43a86
jmp 0x43a33
jmp 0x43a66
jmp 0x43a86
jmp 0x43a33
jmp 0x43a86
jmp 0x43a33
jmp 0x43a66
jmp 0x43a86
jmp 0x43a33
jmp 0x43a86
jmp 0x43a66
jmp 0x43a66
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
jne 0x43a57
jmp 0x43a69
jmp 0x43a66
jmp 0x43a86
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43a69
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x43a69
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x43a89
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x43a89
jmp 0x43a86
jmp 0x43a86
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x43aa0
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes[abi:cxx11](testing::TestResult const&) | std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
const TestResult& result) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << " " << property.key() << "="
<< "\"" << EscapeXmlAttribute(property.value()) << "\"";
}
return attributes.GetString();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x37e78
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
testl %eax, %eax
jle 0x43bf9
movq 0x8(%rsp), %r15
addq $0x10, %r15
xorl %ebp, %ebp
leaq 0x38(%rsp), %r12
movq %r14, %rdi
movl %ebp, %esi
callq 0x3b9ae
movq %rax, %r13
movl $0x1, %edx
movq %r15, %rdi
leaq 0x23e51(%rip), %rsi # 0x67959
callq 0x10560
movq (%r13), %rbx
testq %rbx, %rbx
je 0x43b23
movq %rbx, %rdi
callq 0x101b0
movq %rax, %rdx
jmp 0x43b2f
movl $0x6, %edx
leaq 0x1faec(%rip), %rbx # 0x6361b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10560
movl $0x1, %edx
movq %r15, %rdi
leaq 0x1fa9b(%rip), %rsi # 0x635e4
callq 0x10560
movl $0x1, %edx
movq %r15, %rdi
leaq 0x24984(%rip), %rsi # 0x684e1
callq 0x10560
movq 0x20(%r13), %rsi
movq %r12, %rdi
leaq 0x7(%rsp), %rdx
callq 0x5424e
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x40c7c
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r15, %rdi
callq 0x10560
movl $0x1, %edx
movq %r15, %rdi
leaq 0x2493b(%rip), %rsi # 0x684e1
callq 0x10560
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x43bc7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x43be3
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x10490
incl %ebp
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jl 0x43aec
movq 0x8(%rsp), %rbx
movq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x380ed
testq %rbx, %rbx
je 0x43c1c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x43c76
jmp 0x43c76
movq %rax, %rbx
jmp 0x43c58
jmp 0x43c76
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x43c58
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x43c79
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x43c79
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x43c89
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* jsonout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintJsonUnitTest(&stream, unit_test);
fprintf(jsonout, "%s", StringStreamToString(&stream).c_str());
fclose(jsonout);
} | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x401a8
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x10310
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x43e10
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x380ed
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x10540
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x43db4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x10460
movq 0x461cd(%rip), %rsi # 0x89f90
leaq 0x20(%rsp), %rdi
callq 0x10360
leaq 0xa0(%rsp), %rdi
callq 0x10140
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x43de7
movq %rax, %rbx
movq 0x4619f(%rip), %rsi # 0x89f90
leaq 0x20(%rsp), %rdi
callq 0x10360
leaq 0xa0(%rsp), %rdi
callq 0x10140
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | void JsonUnitTestResultPrinter::OutputJsonKey(
std::ostream* stream,
const std::string& element_name,
const std::string& name,
const std::string& value,
const std::string& indent,
bool comma) {
const std::vector<std::string>& allowed_names =
GetReservedOutputAttributesForElement(element_name);
GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
allowed_names.end())
<< "Key \"" << name << "\" is not allowed for value \"" << element_name
<< "\".";
*stream << indent << "\"" << name << "\": \"" << EscapeJson(value) << "\"";
if (comma)
*stream << ",\n";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x41f50
movq (%rbp), %rdi
movq 0x8(%rbp), %rsi
movq %r15, %rdx
callq 0x58e46
cmpq 0x38(%rsp), %rax
jne 0x4473d
leaq 0x22e83(%rip), %rdx # 0x67524
leaq 0x10(%rsp), %rdi
movl $0x3, %esi
movl $0x119d, %ecx # imm = 0x119D
callq 0x515a8
movq 0x4592c(%rip), %rdi # 0x89fe8
leaq 0x23b86(%rip), %rsi # 0x68249
movl $0x65, %edx
callq 0x10560
movq 0x45914(%rip), %rdi # 0x89fe8
leaq 0x23d9e(%rip), %rsi # 0x68479
movl $0x5, %edx
callq 0x10560
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x458f5(%rip), %rdi # 0x89fe8
callq 0x10560
movq %rax, %rbp
leaq 0x23d7d(%rip), %rsi # 0x6847f
movl $0x1c, %edx
movq %rax, %rdi
callq 0x10560
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbp, %rdi
callq 0x10560
leaq 0x23d76(%rip), %rsi # 0x6849c
movl $0x2, %edx
movq %rax, %rdi
callq 0x10560
leaq 0x10(%rsp), %rdi
callq 0x516ea
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x10560
movq %rax, %r12
leaq 0x23d89(%rip), %rsi # 0x684e1
movl $0x1, %edx
movq %rax, %rdi
callq 0x10560
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x10560
movq %rax, %r15
leaq 0x23d60(%rip), %rsi # 0x684de
movl $0x4, %edx
movq %rax, %rdi
callq 0x10560
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x4447e
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r15, %rdi
callq 0x10560
leaq 0x23d30(%rip), %rsi # 0x684e1
movl $0x1, %edx
movq %rax, %rdi
callq 0x10560
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x447d9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
cmpb $0x0, 0xc(%rsp)
je 0x447f4
leaq 0x23cfd(%rip), %rsi # 0x684e4
movl $0x2, %edx
movq %rbx, %rdi
callq 0x10560
leaq 0x30(%rsp), %rdi
callq 0x543a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x44842
jmp 0x44842
jmp 0x44842
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x44845
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x44845
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x516ea
jmp 0x44845
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x543a0
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonTestInfo(std::ostream*, char const*, testing::TestInfo const&) | void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
const char* test_suite_name,
const TestInfo& test_info) {
const TestResult& result = *test_info.result();
const std::string kTestsuite = "testcase";
const std::string kIndent = Indent(10);
*stream << Indent(8) << "{\n";
OutputJsonKey(stream, kTestsuite, "name", test_info.name(), kIndent);
if (test_info.value_param() != nullptr) {
OutputJsonKey(stream, kTestsuite, "value_param", test_info.value_param(),
kIndent);
}
if (test_info.type_param() != nullptr) {
OutputJsonKey(stream, kTestsuite, "type_param", test_info.type_param(),
kIndent);
}
if (GTEST_FLAG(list_tests)) {
OutputJsonKey(stream, kTestsuite, "file", test_info.file(), kIndent);
OutputJsonKey(stream, kTestsuite, "line", test_info.line(), kIndent, false);
*stream << "\n" << Indent(8) << "}";
return;
}
OutputJsonKey(stream, kTestsuite, "status",
test_info.should_run() ? "RUN" : "NOTRUN", kIndent);
OutputJsonKey(stream, kTestsuite, "result",
test_info.should_run()
? (result.Skipped() ? "SKIPPED" : "COMPLETED")
: "SUPPRESSED",
kIndent);
OutputJsonKey(stream, kTestsuite, "timestamp",
FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
kIndent);
OutputJsonKey(stream, kTestsuite, "time",
FormatTimeInMillisAsDuration(result.elapsed_time()), kIndent);
OutputJsonKey(stream, kTestsuite, "classname", test_suite_name, kIndent,
false);
*stream << TestPropertiesAsJson(result, kIndent);
int failures = 0;
for (int i = 0; i < result.total_part_count(); ++i) {
const TestPartResult& part = result.GetTestPartResult(i);
if (part.failed()) {
*stream << ",\n";
if (++failures == 1) {
*stream << kIndent << "\"" << "failures" << "\": [\n";
}
const std::string location =
internal::FormatCompilerIndependentFileLocation(part.file_name(),
part.line_number());
const std::string message = EscapeJson(location + "\n" + part.message());
*stream << kIndent << " {\n"
<< kIndent << " \"failure\": \"" << message << "\",\n"
<< kIndent << " \"type\": \"\"\n"
<< kIndent << " }";
}
}
if (failures > 0)
*stream << "\n" << kIndent << "]";
*stream << "\n" << Indent(8) << "}";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r15
movq %rsi, 0xb0(%rsp)
movq %rdi, %r12
movabsq $0x2020202020202020, %r13 # imm = 0x2020202020202020
leaq 0x80(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x2385a(%rip), %rsi # 0x682e0
leaq 0x2385b(%rip), %rdx # 0x682e8
leaq 0x70(%rsp), %rdi
callq 0x2e262
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
movq %r13, (%r14)
movw $0x2020, 0x8(%r14) # imm = 0x2020
movq $0xa, -0x8(%r14)
xorl %eax, %eax
movb %al, 0xa(%r14)
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %r13, (%rbp)
movq $0x8, -0x8(%rbp)
movb %al, 0x8(%rbp)
movl $0x8, %edx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x10560
leaq 0x239e8(%rip), %rsi # 0x684cf
movl $0x2, %edx
movq %rax, %rdi
callq 0x10560
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x44b0b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x2383b(%rip), %rsi # 0x68355
leaq 0x23838(%rip), %rdx # 0x68359
callq 0x2e262
movq 0x20(%r15), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x5424e
leaq 0x70(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x48(%rsp), %r8
movq %r12, %rdi
movl $0x1, %r9d
callq 0x44650
leaq 0x38(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x44b79
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x44b90
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x48(%r15), %rax
testq %rax, %rax
je 0x44c34
cmpq $0x0, (%rax)
je 0x44c34
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x23733(%rip), %rsi # 0x682e9
leaq 0x23737(%rip), %rdx # 0x682f4
callq 0x2e262
movq 0x48(%r15), %rax
testq %rax, %rax
je 0x44bd0
movq (%rax), %rsi
jmp 0x44bd2
xorl %esi, %esi
leaq 0x28(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x5424e
leaq 0x70(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x48(%rsp), %r8
movq %r12, %rdi
movl $0x1, %r9d
callq 0x44650
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x44c1d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x44c34
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x40(%r15), %rax
testq %rax, %rax
je 0x44cd8
cmpq $0x0, (%rax)
je 0x44cd8
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x2369b(%rip), %rsi # 0x682f5
leaq 0x2369e(%rip), %rdx # 0x682ff
callq 0x2e262
movq 0x40(%r15), %rax
testq %rax, %rax
je 0x44c74
movq (%rax), %rsi
jmp 0x44c76
xorl %esi, %esi
leaq 0x28(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x5424e
leaq 0x70(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x48(%rsp), %r8
movq %r12, %rdi
movl $0x1, %r9d
callq 0x44650
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x44cc1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x44cd8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
cmpb $0x1, 0x45b6a(%rip) # 0x8a849
jne 0x44e6a
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x2360c(%rip), %rsi # 0x68300
leaq 0x23609(%rip), %rdx # 0x68304
callq 0x2e262
movq 0x50(%r15), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x5424e
leaq 0x70(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x48(%rsp), %r8
movq %r12, %rdi
movl $0x1, %r9d
callq 0x44650
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x44d4f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x44d66
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x23590(%rip), %rsi # 0x68305
leaq 0x2358d(%rip), %rdx # 0x68309
callq 0x2e262
movl 0x70(%r15), %ecx
leaq 0x70(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x48(%rsp), %r8
movq %r12, %rdi
xorl %r9d, %r9d
callq 0x44858
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x44db6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x23369(%rip), %rsi # 0x68126
movl $0x1, %edx
movq %r12, %rdi
callq 0x10560
movq %rbp, 0x8(%rsp)
movabsq $0x2020202020202020, %rax # imm = 0x2020202020202020
movq %rax, 0x18(%rsp)
movq $0x8, 0x10(%rsp)
movb $0x0, 0x20(%rsp)
movl $0x8, %edx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x10560
leaq 0x236f6(%rip), %rsi # 0x684f9
movl $0x1, %edx
movq %rax, %rdi
callq 0x10560
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x44e27
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x44e3e
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x70(%rsp), %rdi
cmpq %rbx, %rdi
je 0x44e58
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x10490
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x23496(%rip), %rsi # 0x6830f
leaq 0x23495(%rip), %rdx # 0x68315
callq 0x2e262
movzbl 0x80(%r15), %eax
leaq 0x23612(%rip), %rcx # 0x684a6
leaq 0x23608(%rip), %rsi # 0x684a3
testq %rax, %rax
cmovneq %rcx, %rsi
leaq 0x28(%rsp), %rdi
movq %r13, (%rdi)
xorq $0x1, %rax
leaq (%rax,%rax,2), %rax
leaq (%rsi,%rax), %rdx
addq $0x3, %rdx
callq 0x2e262
leaq 0x70(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x48(%rsp), %r8
movq %r12, %rdi
movl $0x1, %r9d
callq 0x44650
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x44ef8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x44f0f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x233ff(%rip), %rsi # 0x6831d
leaq 0x233fe(%rip), %rdx # 0x68323
callq 0x2e262
leaq 0x90(%r15), %r14
cmpb $0x1, 0x80(%r15)
movq %r12, 0x68(%rsp)
jne 0x44f5e
movq %r14, %rdi
callq 0x3c030
leaq 0x2355b(%rip), %rcx # 0x684aa
leaq 0x2355c(%rip), %rbx # 0x684b2
testb %al, %al
cmovneq %rcx, %rbx
jmp 0x44f65
leaq 0x23557(%rip), %rbx # 0x684bc
leaq 0x28(%rsp), %r12
movq %r13, (%r12)
movq %rbx, %rdi
callq 0x101b0
leaq (%rax,%rbx), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2e262
leaq 0x70(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x48(%rsp), %r8
movq 0x68(%rsp), %rbx
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x44650
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x44fc3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x44fda
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x2335d(%rip), %rsi # 0x68346
leaq 0x2335f(%rip), %rdx # 0x6834f
callq 0x2e262
movq 0x100(%r15), %rsi
leaq 0x28(%rsp), %rdi
callq 0x456df
leaq 0x70(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x48(%rsp), %r8
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x44650
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x4503f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x45056
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x232dc(%rip), %rsi # 0x68341
leaq 0x232d9(%rip), %rdx # 0x68345
callq 0x2e262
movq 0x108(%r15), %rsi
leaq 0x28(%rsp), %rdi
callq 0x46249
leaq 0x70(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x48(%rsp), %r8
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x44650
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x450bb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x450d2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x2326f(%rip), %rsi # 0x68350
leaq 0x23271(%rip), %rdx # 0x68359
callq 0x2e262
leaq 0x28(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movq 0xb0(%rsp), %rsi
callq 0x5424e
leaq 0x70(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x48(%rsp), %r8
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x44650
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x4513d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x45154
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r14, %rsi
callq 0x462ea
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4518f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0xd0(%r15), %rax
subq 0xc8(%r15), %rax
shrq $0x4, %rax
imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7
testl %eax, %eax
jle 0x454d7
movq %r14, 0xb0(%rsp)
xorl %ebp, %ebp
xorl %r14d, %r14d
movq 0xb0(%rsp), %rdi
movl %ebp, %esi
callq 0x3b940
movq %rax, %rbx
movl (%rax), %eax
decl %eax
cmpl $0x1, %eax
ja 0x4546c
movl $0x2, %edx
movq 0x68(%rsp), %rdi
leaq 0x232f8(%rip), %rsi # 0x684e4
callq 0x10560
testl %r14d, %r14d
jne 0x45249
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x68(%rsp), %rdi
callq 0x10560
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0x232c5(%rip), %rsi # 0x684e1
callq 0x10560
movl $0x8, %edx
movq %r12, %rdi
leaq 0x23d90(%rip), %rsi # 0x68fc0
callq 0x10560
movl $0x5, %edx
movq %r12, %rdi
leaq 0x23283(%rip), %rsi # 0x684c7
callq 0x10560
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x45256
movq 0x8(%rbx), %rsi
movq %r15, %r13
movl 0x28(%rbx), %edx
leaq 0x8(%rsp), %rdi
callq 0x42ee5
movq 0x68(%rsp), %r12
leaq 0xc8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0xb8(%rsp), %r15
movq %r15, %rdi
callq 0x3078a
movq %r15, %rdi
leaq 0x22e84(%rip), %rsi # 0x68126
callq 0x2e96e
movq 0x50(%rbx), %rsi
movq %r15, %rdi
callq 0x2e96e
leaq 0xa0(%rsp), %rsi
movq %rsi, 0x90(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
movq %r13, %r15
je 0x452ea
movq %rdx, 0x90(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xa0(%rsp)
jmp 0x452f0
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x98(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x28(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x4447e
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x45342
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x45367
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %r12, %rdi
callq 0x10560
movq %rax, %rbx
movl $0x4, %edx
movq %rax, %rdi
leaq 0x23142(%rip), %rsi # 0x684cd
callq 0x10560
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
movq %rax, %rbx
movl $0x10, %edx
movq %rax, %rdi
leaq 0x2311e(%rip), %rsi # 0x684d2
callq 0x10560
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
movq %rax, %rbx
movl $0x3, %edx
movq %rax, %rdi
leaq 0x23106(%rip), %rsi # 0x684e3
callq 0x10560
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
movq %rax, %rbx
movl $0xf, %edx
movq %rax, %rdi
leaq 0x230e1(%rip), %rsi # 0x684e7
callq 0x10560
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
movl $0x3, %edx
movq %rax, %rdi
leaq 0x230cb(%rip), %rsi # 0x684f7
callq 0x10560
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x4544d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x45469
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
incl %r14d
movq 0xd0(%r15), %rax
subq 0xc8(%r15), %rax
incl %ebp
shrq $0x4, %rax
imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7
cmpl %eax, %ebp
jl 0x451bc
testl %r14d, %r14d
leaq 0x18(%rsp), %rbp
movq 0x68(%rsp), %rbx
jle 0x454d7
leaq 0x22c82(%rip), %rsi # 0x68126
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10560
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
leaq 0x238f1(%rip), %rsi # 0x68dbb
movl $0x1, %edx
movq %rax, %rdi
callq 0x10560
leaq 0x22c48(%rip), %rsi # 0x68126
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10560
movq %rbp, 0x8(%rsp)
movabsq $0x2020202020202020, %rax # imm = 0x2020202020202020
movq %rax, 0x18(%rsp)
movq $0x8, 0x10(%rsp)
movb $0x0, 0x20(%rsp)
movl $0x8, %edx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x10560
leaq 0x22fd5(%rip), %rsi # 0x684f9
movl $0x1, %edx
movq %rax, %rdi
callq 0x10560
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
leaq 0x80(%rsp), %rbx
leaq 0x58(%rsp), %r14
jne 0x44e1a
jmp 0x44e27
jmp 0x455ee
jmp 0x455a7
jmp 0x455ee
jmp 0x455a7
jmp 0x45659
jmp 0x455ee
jmp 0x45659
jmp 0x455ee
jmp 0x45659
jmp 0x455a7
jmp 0x455ee
jmp 0x45659
jmp 0x455a7
jmp 0x455ee
jmp 0x45659
jmp 0x455a7
jmp 0x455ee
jmp 0x45659
jmp 0x455a7
jmp 0x45659
jmp 0x455ee
jmp 0x455ee
jmp 0x45659
jmp 0x45659
jmp 0x455a7
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
jne 0x455d9
jmp 0x455f1
jmp 0x455ee
jmp 0x455ee
jmp 0x45659
jmp 0x45659
jmp 0x455ee
jmp 0x455ee
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x455f1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x455f1
jmp 0x455ee
jmp 0x45659
jmp 0x45659
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
jne 0x4568c
jmp 0x45699
movq %rax, %r14
jmp 0x4567d
jmp 0x4560d
jmp 0x45659
movq %rax, %r14
jmp 0x4563a
movq %rax, %r14
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x4563a
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x4567d
movq 0xc8(%rsp), %rsi
jmp 0x45675
movq %rax, %r14
jmp 0x45699
movq %rax, %r14
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x4567d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x45699
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x456b5
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x456d7
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x10490
movq %r14, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::FormatEpochTimeInMillisAsRFC3339[abi:cxx11](long) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
struct tm time_struct;
if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
return "";
// YYYY-MM-DDThh:mm:ss
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) + "Z";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rsi, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, (%rdi)
leaq 0x210(%rsp), %rsi
callq 0x10220
testq %rax, %rax
je 0x45790
movl $0x76c, %eax # imm = 0x76C
addl 0x224(%rsp), %eax
leaq 0x1ec(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x1f0(%rsp), %r14
movq %r14, %rdi
callq 0x56350
leaq 0x23157(%rip), %rsi # 0x688af
movq %r14, %rdi
callq 0x2e96e
leaq 0xb8(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x457ae
movq %rdx, 0xa8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xb8(%rsp)
jmp 0x457b5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x22989(%rip), %rdx # 0x68127
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2e262
jmp 0x45feb
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0xb0(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x220(%rsp), %esi
incl %esi
leaq 0x1c8(%rsp), %rdi
movl $0x2, %edx
callq 0x3b718
movq 0xa8(%rsp), %rcx
movq 0xb0(%rsp), %r8
movq 0x1d0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r14, %rcx
je 0x45819
movq 0xb8(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x4583e
leaq 0x1d8(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x45839
movq 0x1d8(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x45855
movq 0x1c8(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x2e9b4
jmp 0x45866
leaq 0x1c8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2ebfa
leaq 0x38(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x4588a
movq %rsi, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x45890
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x22ffb(%rip), %rsi # 0x688af
leaq 0x28(%rsp), %rdi
callq 0x2e96e
leaq 0xd8(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x458ee
movq %rdx, 0xc8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xd8(%rsp)
jmp 0x458f5
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0xd0(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x21c(%rsp), %esi
leaq 0x1a8(%rsp), %rdi
movl $0x2, %edx
callq 0x3b718
movq 0xc8(%rsp), %rcx
movq 0xd0(%rsp), %r8
movq 0x1b0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r15, %rcx
je 0x45957
movq 0xd8(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x4597c
leaq 0x1b8(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x45977
movq 0x1b8(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x45993
movq 0x1a8(%rsp), %rsi
leaq 0xc8(%rsp), %rdi
callq 0x2e9b4
jmp 0x459a4
leaq 0x1a8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2ebfa
leaq 0x58(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x459c8
movq %rsi, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x459ce
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x1d57e(%rip), %rsi # 0x62f70
leaq 0x48(%rsp), %rdi
callq 0x2e96e
leaq 0xf8(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x45a2d
movq %rdx, 0xe8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xf8(%rsp)
jmp 0x45a35
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0xf0(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x218(%rsp), %esi
leaq 0x188(%rsp), %rdi
movl $0x2, %edx
callq 0x3b718
movq 0xe8(%rsp), %rcx
movq 0xf0(%rsp), %r8
movq 0x190(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x45a97
movq 0xf8(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x45abc
leaq 0x198(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x45ab7
movq 0x198(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x45ad3
movq 0x188(%rsp), %rsi
leaq 0xe8(%rsp), %rdi
callq 0x2e9b4
jmp 0x45ae4
leaq 0x188(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2ebfa
leaq 0x78(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x45b08
movq %rsi, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
jmp 0x45b0e
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x70(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x22ab2(%rip), %rsi # 0x685e4
leaq 0x68(%rsp), %rdi
callq 0x2e96e
leaq 0x118(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x45b6c
movq %rdx, 0x108(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x118(%rsp)
jmp 0x45b74
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x110(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x214(%rsp), %esi
leaq 0x168(%rsp), %rdi
movl $0x2, %edx
callq 0x3b718
movq 0x108(%rsp), %rcx
movq 0x110(%rsp), %r8
movq 0x170(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r13, %rcx
je 0x45bd6
movq 0x118(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x45bfb
leaq 0x178(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x45bf6
movq 0x178(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x45c12
movq 0x168(%rsp), %rsi
leaq 0x108(%rsp), %rdi
callq 0x2e9b4
jmp 0x45c23
leaq 0x168(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2ebfa
leaq 0x98(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x45c50
movq %rsi, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
jmp 0x45c56
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x90(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x22967(%rip), %rsi # 0x685e4
leaq 0x88(%rsp), %rdi
callq 0x2e96e
leaq 0x138(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x45cba
movq %rdx, 0x128(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x138(%rsp)
jmp 0x45cc1
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
movq %rdx, 0x130(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x210(%rsp), %esi
leaq 0x148(%rsp), %rdi
movl $0x2, %edx
callq 0x3b718
movq 0x128(%rsp), %rcx
movq 0x130(%rsp), %r8
movq 0x150(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %rbp, %rcx
je 0x45d23
movq 0x138(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x45d48
leaq 0x158(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x45d43
movq 0x158(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x45d5f
movq 0x148(%rsp), %rsi
leaq 0x128(%rsp), %rdi
callq 0x2e9b4
jmp 0x45d70
leaq 0x148(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2ebfa
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x45d94
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x45d9a
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x23510(%rip), %rsi # 0x692ce
leaq 0x8(%rsp), %rdi
callq 0x2e96e
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x45dea
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x45df0
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 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45e22
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x158(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45e43
movq 0x158(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x128(%rsp), %rdi
cmpq %rbp, %rdi
je 0x45e60
movq 0x138(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45e81
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x178(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45ea2
movq 0x178(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x108(%rsp), %rdi
cmpq %r13, %rdi
je 0x45ebf
movq 0x118(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45eda
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x198(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45efb
movq 0x198(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0xe8(%rsp), %rdi
cmpq %r12, %rdi
je 0x45f18
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45f33
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x1b8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45f54
movq 0x1b8(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0xc8(%rsp), %rdi
cmpq %r15, %rdi
je 0x45f71
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45f8c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x1d8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45fad
movq 0x1d8(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0xa8(%rsp), %rdi
cmpq %r14, %rdi
je 0x45fca
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x200(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45feb
movq 0x200(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rax
addq $0x248, %rsp # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46023
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x46023
movq %rax, %rbx
leaq 0x158(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46049
movq 0x158(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x46049
movq %rax, %rbx
movq 0x128(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4606b
movq 0x138(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x4606b
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46091
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x46091
movq %rax, %rbx
leaq 0x178(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x460b7
movq 0x178(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x460b7
movq %rax, %rbx
movq 0x108(%rsp), %rdi
cmpq %r13, %rdi
je 0x460d9
movq 0x118(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x460d9
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x460f9
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x460f9
movq %rax, %rbx
leaq 0x198(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4611f
movq 0x198(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x4611f
movq %rax, %rbx
movq 0xe8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4613c
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46157
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x1b8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46178
movq 0x1b8(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0xc8(%rsp), %rdi
cmpq %r15, %rdi
je 0x46195
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x461b0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x1d8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x461d1
movq 0x1d8(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0xa8(%rsp), %rdi
cmpq %r14, %rdi
je 0x461ee
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x200(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4620f
movq 0x200(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
movq %rax, %rbx
jmp 0x4613c
movq %rax, %rbx
jmp 0x46157
movq %rax, %rbx
jmp 0x46178
movq %rax, %rbx
jmp 0x46195
movq %rax, %rbx
jmp 0x461b0
movq %rax, %rbx
jmp 0x461d1
movq %rax, %rbx
jmp 0x461ee
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::FormatTimeInMillisAsDuration[abi:cxx11](long) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
::std::stringstream ss;
ss << (static_cast<double>(ms) * 1e-3) << "s";
return ss.str();
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x10310
leaq 0x10(%rsp), %rdi
cvtsi2sd %r14, %xmm0
mulsd 0x20095(%rip), %xmm0 # 0x66308
callq 0x10820
leaq 0x2261b(%rip), %rsi # 0x6889a
movl $0x1, %edx
movq %rax, %rdi
callq 0x10560
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x10350
movq 0x43cf0(%rip), %rsi # 0x89f90
movq %rsp, %rdi
callq 0x10360
leaq 0x80(%rsp), %rdi
callq 0x10140
movq %rbx, %rax
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x43cc3(%rip), %rsi # 0x89f90
movq %rsp, %rdi
callq 0x10360
leaq 0x80(%rsp), %rdi
callq 0x10140
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::TestPropertiesAsJson(testing::TestResult const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
const TestResult& result, const std::string& indent) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << ",\n" << indent << "\"" << property.key() << "\": "
<< "\"" << EscapeJson(property.value()) << "\"";
}
return attributes.GetString();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x30(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x37e78
movq 0x58(%r15), %rax
subq 0x50(%r15), %rax
shrq $0x6, %rax
testl %eax, %eax
jle 0x4645c
movq 0x8(%rsp), %r12
addq $0x10, %r12
xorl %ebp, %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0x3b9ae
movq %rax, %r13
movl $0x2, %edx
movq %r12, %rdi
leaq 0x2219c(%rip), %rsi # 0x684e4
callq 0x10560
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x10560
movl $0x1, %edx
movq %r12, %rdi
leaq 0x22176(%rip), %rsi # 0x684e1
callq 0x10560
movq (%r13), %rbx
testq %rbx, %rbx
je 0x46386
movq %rbx, %rdi
callq 0x101b0
movq %rax, %rdx
jmp 0x46392
movl $0x6, %edx
leaq 0x1d289(%rip), %rbx # 0x6361b
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10560
movl $0x3, %edx
movq %r12, %rdi
leaq 0x220f3(%rip), %rsi # 0x6849f
callq 0x10560
movl $0x1, %edx
movq %r12, %rdi
leaq 0x22121(%rip), %rsi # 0x684e1
callq 0x10560
movq 0x20(%r13), %rsi
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
leaq 0x7(%rsp), %rdx
callq 0x5424e
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x4447e
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x10560
movl $0x1, %edx
movq %r12, %rdi
leaq 0x220d8(%rip), %rsi # 0x684e1
callq 0x10560
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x4642a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x46446
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x10490
incl %ebp
movq 0x58(%r15), %rax
subq 0x50(%r15), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jl 0x4632c
movq 0x8(%rsp), %rbx
movq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x380ed
testq %rbx, %rbx
je 0x4647f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x464d9
jmp 0x464d9
movq %rax, %rbx
jmp 0x464b9
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x464b9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x464dc
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x464dc
jmp 0x464d9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x464ec
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonTestSuite(std::ostream*, testing::TestSuite const&) | void JsonUnitTestResultPrinter::PrintJsonTestSuite(
std::ostream* stream, const TestSuite& test_suite) {
const std::string kTestsuite = "testsuite";
const std::string kIndent = Indent(6);
*stream << Indent(4) << "{\n";
OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);
OutputJsonKey(stream, kTestsuite, "tests", test_suite.reportable_test_count(),
kIndent);
if (!GTEST_FLAG(list_tests)) {
OutputJsonKey(stream, kTestsuite, "failures",
test_suite.failed_test_count(), kIndent);
OutputJsonKey(stream, kTestsuite, "disabled",
test_suite.reportable_disabled_test_count(), kIndent);
OutputJsonKey(stream, kTestsuite, "errors", 0, kIndent);
OutputJsonKey(
stream, kTestsuite, "timestamp",
FormatEpochTimeInMillisAsRFC3339(test_suite.start_timestamp()),
kIndent);
OutputJsonKey(stream, kTestsuite, "time",
FormatTimeInMillisAsDuration(test_suite.elapsed_time()),
kIndent, false);
*stream << TestPropertiesAsJson(test_suite.ad_hoc_test_result(), kIndent)
<< ",\n";
}
*stream << kIndent << "\"" << kTestsuite << "\": [\n";
bool comma = false;
for (int i = 0; i < test_suite.total_test_count(); ++i) {
if (test_suite.GetTestInfo(i)->is_reportable()) {
if (comma) {
*stream << ",\n";
} else {
comma = true;
}
OutputJsonTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
}
}
*stream << "\n" << kIndent << "]\n" << Indent(4) << "}";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x21ea5(%rip), %rsi # 0x683c0
leaq 0x21ea7(%rip), %rdx # 0x683c9
leaq 0x68(%rsp), %rdi
callq 0x2e262
leaq 0x38(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movl $0x20202020, %eax # imm = 0x20202020
movl %eax, (%rdx)
movw $0x2020, 0x4(%rdx) # imm = 0x2020
movq $0x6, -0x8(%rdx)
xorl %ecx, %ecx
movb %cl, 0x6(%rdx)
leaq 0x10(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movl %eax, (%rbx)
movq $0x4, -0x8(%rbx)
movb %cl, 0x4(%rbx)
movl $0x4, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10560
leaq 0x21f53(%rip), %rsi # 0x684cf
movl $0x2, %edx
movq %rax, %rdi
callq 0x10560
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x4659f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rsp, %rdi
movq %rbx, (%rdi)
leaq 0x21da9(%rip), %rsi # 0x68355
leaq 0x21da6(%rip), %rdx # 0x68359
callq 0x2e262
movq 0x8(%r15), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x27(%rsp), %rdx
callq 0x5424e
leaq 0x68(%rsp), %rsi
movq %rsp, %rdx
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r8
movq %r14, %rdi
movl $0x1, %r9d
callq 0x44650
leaq 0x58(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x46607
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x4661d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rsp, %rdi
movq %rbx, (%rdi)
leaq 0x21a7f(%rip), %rsi # 0x680a9
leaq 0x21a7d(%rip), %rdx # 0x680ae
callq 0x2e262
movq 0x30(%r15), %rax
movq 0x38(%r15), %rdx
cmpq %rdx, %rax
je 0x4666f
xorl %esi, %esi
xorl %ecx, %ecx
movq (%rax), %rdi
movzbl 0x83(%rdi), %r8d
xorl $0x1, %r8d
cmpb $0x0, 0x82(%rdi)
cmovel %esi, %r8d
addl %r8d, %ecx
addq $0x8, %rax
cmpq %rdx, %rax
jne 0x46647
jmp 0x46671
xorl %ecx, %ecx
leaq 0x68(%rsp), %rsi
movq %rsp, %rdx
leaq 0x28(%rsp), %r8
movq %r14, %rdi
movl $0x1, %r9d
callq 0x44858
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x466a2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
cmpb $0x0, 0x441a0(%rip) # 0x8a849
jne 0x46908
movq %rsp, %rdi
movq %rbx, (%rdi)
leaq 0x22904(%rip), %rsi # 0x68fc0
leaq 0x22905(%rip), %rdx # 0x68fc8
callq 0x2e262
movq %r15, %rdi
callq 0x37974
leaq 0x68(%rsp), %rsi
movq %rsp, %rdx
leaq 0x28(%rsp), %r8
movq %r14, %rdi
movl %eax, %ecx
movl $0x1, %r9d
callq 0x44858
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x46703
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rsp, %rdi
movq %rbx, (%rdi)
leaq 0x21cbe(%rip), %rsi # 0x683ce
leaq 0x21cbf(%rip), %rdx # 0x683d6
callq 0x2e262
movq 0x30(%r15), %rax
movq 0x38(%r15), %rdx
xorl %ecx, %ecx
cmpq %rdx, %rax
je 0x46754
movq (%rax), %rsi
cmpb $0x1, 0x82(%rsi)
movl $0x0, %edi
jne 0x4674c
testb $0x1, 0x83(%rsi)
jne 0x4674c
movzbl 0x81(%rsi), %edi
addl %edi, %ecx
addq $0x8, %rax
jmp 0x46726
leaq 0x68(%rsp), %rsi
movq %rsp, %rdx
leaq 0x28(%rsp), %r8
movq %r14, %rdi
movl $0x1, %r9d
callq 0x44858
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x46785
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rsp, %rdi
movq %rbx, (%rdi)
leaq 0x21c45(%rip), %rsi # 0x683d7
leaq 0x21c44(%rip), %rdx # 0x683dd
callq 0x2e262
leaq 0x68(%rsp), %rsi
movq %rsp, %rdx
leaq 0x28(%rsp), %r8
movq %r14, %rdi
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x44858
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x467d1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rsp, %rdi
movq %rbx, (%rdi)
leaq 0x21b68(%rip), %rsi # 0x68346
leaq 0x21b6a(%rip), %rdx # 0x6834f
callq 0x2e262
movq 0x78(%r15), %rsi
leaq 0x48(%rsp), %rdi
callq 0x456df
leaq 0x68(%rsp), %rsi
movq %rsp, %rdx
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r8
movq %r14, %rdi
movl $0x1, %r9d
callq 0x44650
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x4682f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x46845
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rsp, %rdi
movq %rbx, (%rdi)
leaq 0x21aef(%rip), %rsi # 0x68341
leaq 0x21aec(%rip), %rdx # 0x68345
callq 0x2e262
movq 0x80(%r15), %rsi
leaq 0x48(%rsp), %rdi
callq 0x46249
leaq 0x68(%rsp), %rsi
movq %rsp, %rdx
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r8
movq %r14, %rdi
xorl %r9d, %r9d
callq 0x44650
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x468a3
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x468b9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x88(%r15), %rsi
movq %rsp, %rdi
leaq 0x28(%rsp), %rdx
callq 0x462ea
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x10560
leaq 0x21bff(%rip), %rsi # 0x684e4
movl $0x2, %edx
movq %rax, %rdi
callq 0x10560
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x46908
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x10560
movq %rax, %r12
leaq 0x21bbd(%rip), %rsi # 0x684e1
movl $0x1, %edx
movq %rax, %rdi
callq 0x10560
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq %r12, %rdi
callq 0x10560
leaq 0x21b7d(%rip), %rsi # 0x684c7
movl $0x5, %edx
movq %rax, %rdi
callq 0x10560
movq 0x30(%r15), %rax
movq 0x38(%r15), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x46a26
xorl %r13d, %r13d
leaq 0x21b6c(%rip), %r12 # 0x684e4
xorl %ebx, %ebx
movq 0x48(%r15), %rcx
movq 0x50(%r15), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %rsi, %r13
jge 0x4699a
movl (%rcx,%r13,4), %edx
movl %edx, %ecx
movq (%rax,%rcx,8), %rax
cmpb $0x1, 0x82(%rax)
jne 0x46a04
testb $0x1, 0x83(%rax)
jne 0x46a04
movb $0x1, %bpl
testb $0x1, %bl
je 0x469cc
movl $0x2, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x10560
movl %ebx, %ebp
movq 0x48(%r15), %rax
movq 0x50(%r15), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movslq %ecx, %rdx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq %rdx, %r13
jge 0x469ec
movl (%rax,%r13,4), %ecx
movq 0x8(%r15), %rsi
movl %ecx, %eax
movq 0x30(%r15), %rcx
movq (%rcx,%rax,8), %rdx
movq %r14, %rdi
callq 0x44a4a
jmp 0x46a06
movl %ebx, %ebp
incq %r13
movq 0x30(%r15), %rax
movq 0x38(%r15), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
movl %ebp, %ebx
cmpq %rcx, %r13
jl 0x4697a
leaq 0x216f9(%rip), %rsi # 0x68126
movl $0x1, %edx
movq %r14, %rdi
callq 0x10560
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x10560
movq %rax, %r14
leaq 0x21aa5(%rip), %rsi # 0x684fb
movl $0x2, %edx
movq %rax, %rdi
callq 0x10560
leaq 0x10(%rsp), %rbx
movq %rbx, (%rsp)
movl $0x20202020, 0x10(%rsp) # imm = 0x20202020
movq $0x4, 0x8(%rsp)
movb $0x0, 0x14(%rsp)
movl $0x4, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10560
leaq 0x21a60(%rip), %rsi # 0x684f9
movl $0x1, %edx
movq %rax, %rdi
callq 0x10560
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x46abc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x46ad8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x46af4
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x46b78
jmp 0x46b0e
jmp 0x46b59
jmp 0x46b78
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
jne 0x46b44
jmp 0x46b5c
jmp 0x46b59
jmp 0x46b78
jmp 0x46b59
jmp 0x46b78
jmp 0x46b59
jmp 0x46b78
jmp 0x46b78
jmp 0x46b59
jmp 0x46b59
jmp 0x46b59
jmp 0x46b78
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46b5c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x46b5c
jmp 0x46b59
jmp 0x46b78
jmp 0x46b59
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x46b7b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x46b7b
jmp 0x46b78
jmp 0x46b78
movq %rax, %r14
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x46b97
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x46bb3
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
movq %r14, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonTestList(std::ostream*, std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void JsonUnitTestResultPrinter::PrintJsonTestList(
std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
const std::string kTestsuites = "testsuites";
const std::string kIndent = Indent(2);
*stream << "{\n";
int total_tests = 0;
for (auto test_suite : test_suites) {
total_tests += test_suite->total_test_count();
}
OutputJsonKey(stream, kTestsuites, "tests", total_tests, kIndent);
OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
*stream << kIndent << "\"" << kTestsuites << "\": [\n";
for (size_t i = 0; i < test_suites.size(); ++i) {
if (i != 0) {
*stream << ",\n";
}
PrintJsonTestSuite(stream, *test_suites[i]);
}
*stream << "\n"
<< kIndent << "]\n"
<< "}\n";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x217ff(%rip), %rsi # 0x683e3
leaq 0x21802(%rip), %rdx # 0x683ed
leaq 0x48(%rsp), %rdi
callq 0x2e262
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movw $0x2020, (%r13) # imm = 0x2020
movq $0x2, -0x8(%r13)
movb $0x0, 0x2(%r13)
leaq 0x218b6(%rip), %rsi # 0x684cf
movl $0x2, %edx
movq %rbx, %rdi
callq 0x10560
movq (%r14), %rax
movq 0x8(%r14), %rcx
xorl %ebp, %ebp
cmpq %rcx, %rax
je 0x46c4b
movq (%rax), %rdx
movq 0x38(%rdx), %rsi
subq 0x30(%rdx), %rsi
shrq $0x3, %rsi
addl %esi, %ebp
addq $0x8, %rax
jmp 0x46c2f
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2144e(%rip), %rsi # 0x680a9
leaq 0x2144c(%rip), %rdx # 0x680ae
leaq 0x8(%rsp), %rdi
callq 0x2e262
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %r8
movq %rbx, %rdi
movl %ebp, %ecx
movl $0x1, %r9d
callq 0x44858
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x46ca2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x216a4(%rip), %rsi # 0x68355
leaq 0x216a1(%rip), %rdx # 0x68359
callq 0x2e262
leaq 0x78(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x21749(%rip), %rsi # 0x68416
leaq 0x2174a(%rip), %rdx # 0x6841e
leaq 0x68(%rsp), %rdi
callq 0x2e262
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x68(%rsp), %rcx
leaq 0x28(%rsp), %r8
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x44650
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x46d17
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x46d2e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
movq %rax, %r15
leaq 0x21797(%rip), %rsi # 0x684e1
movl $0x1, %edx
movq %rax, %rdi
callq 0x10560
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %r15, %rdi
callq 0x10560
leaq 0x21757(%rip), %rsi # 0x684c7
movl $0x5, %edx
movq %rax, %rdi
callq 0x10560
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x46dc6
xorl %ebp, %ebp
leaq 0x21755(%rip), %r15 # 0x684e4
testq %rbp, %rbp
je 0x46da4
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10560
movq (%r14), %rax
movq (%rax,%rbp,8), %rsi
movq %rbx, %rdi
callq 0x464f4
incq %rbp
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
cmpq %rax, %rbp
jb 0x46d8f
leaq 0x21359(%rip), %rsi # 0x68126
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10560
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x10560
movq %rax, %rbx
leaq 0x21705(%rip), %rsi # 0x684fb
movl $0x2, %edx
movq %rax, %rdi
callq 0x10560
leaq 0x216f4(%rip), %rsi # 0x684fe
movl $0x2, %edx
movq %rbx, %rdi
callq 0x10560
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x46e2e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x46e45
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x46e7a
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x46e7a
jmp 0x46e77
jmp 0x46e99
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x46e9c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x46e9c
jmp 0x46e99
jmp 0x46e99
jmp 0x46e99
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x46eb3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x46eca
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::StreamingListener::UrlEncode[abi:cxx11](char const*) | std::string StreamingListener::UrlEncode(const char* str) {
std::string result;
result.reserve(strlen(str) + 1);
for (char ch = *str; ch != '\0'; ch = *++str) {
switch (ch) {
case '%':
case '=':
case '&':
case '\n':
result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
break;
default:
result.push_back(ch);
break;
}
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x101b0
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x554f4
leaq 0x18(%rsp), %r13
movabsq $0x2000006000000400, %rbp # imm = 0x2000006000000400
leaq 0x28(%rsp), %r15
leaq 0x215d5(%rip), %r12 # 0x68501
movzbl (%r14), %eax
cmpq $0x3d, %rax
ja 0x46ff3
btq %rax, %rbp
jae 0x46fee
movzbl %al, %esi
movq %r15, %rdi
callq 0x3b800
movl $0x1, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x2ebfa
movq %r13, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x46f87
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x46f8f
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2e9b4
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x46fd0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x46ffe
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x46ffe
testq %rax, %rax
je 0x47006
movsbl %al, %esi
movq %rbx, %rdi
callq 0x562f2
incq %r14
jmp 0x46f2c
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x47038
jmp 0x47038
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x47040
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x47040
movq %rax, %r14
jmp 0x4705c
movq %rax, %r14
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x4705c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq (%rsp), %rax
movq (%rbx), %rdi
cmpq %rax, %rdi
je 0x47073
movq (%rax), %rsi
incq %rsi
callq 0x10490
movq %r14, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::StreamingListener::SocketWriter::MakeConnection() | void StreamingListener::SocketWriter::MakeConnection() {
GTEST_CHECK_(sockfd_ == -1)
<< "MakeConnection() can't be called when there is already a connection.";
addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses.
hints.ai_socktype = SOCK_STREAM;
addrinfo* servinfo = nullptr;
// Use the getaddrinfo() to get a linked list of IP addresses for
// the given host name.
const int error_num = getaddrinfo(
host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
if (error_num != 0) {
GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "
<< gai_strerror(error_num);
}
// Loop through all the results and connect to the first we can.
for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr;
cur_addr = cur_addr->ai_next) {
sockfd_ = socket(
cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
if (sockfd_ != -1) {
// Connect the client socket to the server socket.
if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
close(sockfd_);
sockfd_ = -1;
}
}
}
freeaddrinfo(servinfo); // all done with this structure
if (sockfd_ == -1) {
GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to "
<< host_name_ << ":" << port_num_;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
je 0x470e4
leaq 0x2048e(%rip), %rdx # 0x67524
leaq 0x10(%rsp), %rdi
movl $0x3, %esi
movl $0x1298, %ecx # imm = 0x1298
callq 0x515a8
movq 0x42f37(%rip), %rdi # 0x89fe8
leaq 0x2144b(%rip), %rsi # 0x68503
movl $0x20, %edx
callq 0x10560
movq 0x42f1f(%rip), %rdi # 0x89fe8
leaq 0x21454(%rip), %rsi # 0x68524
movl $0x44, %edx
callq 0x10560
leaq 0x10(%rsp), %rdi
callq 0x516ea
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movl $0x1, 0x8(%rdx)
leaq 0x8(%rsp), %rcx
movq $0x0, (%rcx)
movq 0x10(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x10650
testl %eax, %eax
je 0x471a4
movl %eax, %ebp
leaq 0x203fc(%rip), %rdx # 0x67524
leaq 0x4(%rsp), %rdi
movl $0x1, %esi
movl $0x12a6, %ecx # imm = 0x12A6
callq 0x515a8
movq 0x42ea5(%rip), %r14 # 0x89fe8
leaq 0x2141f(%rip), %rsi # 0x68569
movl $0x28, %edx
movq %r14, %rdi
callq 0x10560
movl %ebp, %edi
callq 0x106e0
testq %rax, %rax
je 0x47182
movq %rax, %r15
movq %rax, %rdi
callq 0x101b0
movq 0x42e73(%rip), %rdi # 0x89fe8
movq %r15, %rsi
movq %rax, %rdx
callq 0x10560
jmp 0x4719a
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x10860
leaq 0x4(%rsp), %rdi
callq 0x516ea
movq 0x8(%rsp), %r14
cmpl $-0x1, 0x8(%rbx)
sete %al
testq %r14, %r14
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x47208
movl 0x4(%r14), %edi
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
callq 0x100f0
movl %eax, 0x8(%rbx)
cmpl $-0x1, %eax
je 0x471f9
movq 0x18(%r14), %rsi
movl 0x10(%r14), %edx
movl %eax, %edi
callq 0x103c0
cmpl $-0x1, %eax
jne 0x471f9
movl 0x8(%rbx), %edi
callq 0x10970
movl $0xffffffff, 0x8(%rbx) # imm = 0xFFFFFFFF
cmpl $-0x1, 0x8(%rbx)
jne 0x47208
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x471bd
movq 0x8(%rsp), %rdi
callq 0x10690
cmpl $-0x1, 0x8(%rbx)
jne 0x47290
leaq 0x20305(%rip), %rdx # 0x67524
leaq 0x4(%rsp), %rdi
movl $0x1, %esi
movl $0x12bb, %ecx # imm = 0x12BB
callq 0x515a8
movq 0x42dae(%rip), %rdi # 0x89fe8
leaq 0x21351(%rip), %rsi # 0x68592
movl $0x27, %edx
callq 0x10560
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq 0x42d8e(%rip), %rdi # 0x89fe8
callq 0x10560
movq %rax, %r14
leaq 0x2137b(%rip), %rsi # 0x685e4
movl $0x1, %edx
movq %rax, %rdi
callq 0x10560
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movq %r14, %rdi
callq 0x10560
leaq 0x4(%rsp), %rdi
callq 0x516ea
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x472a7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x472af
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x516ea
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::OsStackTraceGetter::UponLeavingGTest() | GTEST_LOCK_EXCLUDED_(mutex_) {
#if GTEST_HAS_ABSL
void* caller_frame = nullptr;
if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
caller_frame = nullptr;
}
MutexLock lock(&mutex_);
caller_frame_ = caller_frame;
#endif // GTEST_HAS_ABSL
} | retq
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::TestEventListeners::SetDefaultXmlGenerator(testing::TestEventListener*) | void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
if (default_xml_generator_ != listener) {
// It is an error to pass this method a listener that is already in the
// list.
delete Release(default_xml_generator_);
default_xml_generator_ = listener;
if (listener != nullptr) Append(listener);
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
cmpq %rbx, %rsi
je 0x473fa
movq %rdi, %r14
xorl %eax, %eax
cmpq %rsi, 0x8(%rdi)
setne %al
movq $0x0, 0x8(%rdi,%rax,8)
movq (%rdi), %rdi
callq 0x3fbd0
testq %rax, %rax
je 0x473df
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x10(%r14)
testq %rbx, %rbx
je 0x473fa
movq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3fba6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::UnitTest::test_case_to_run_count() const | const internal::UnitTestImpl* impl() const { return impl_; } | movq 0x40(%rdi), %rax
movq 0xb8(%rax), %rcx
movq 0xc0(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x4747a
movq (%rcx), %rsi
movzbl 0x70(%rsi), %esi
addl %esi, %eax
addq $0x8, %rcx
jmp 0x47466
retq
nop
| /ckerr[P]buffy/extern/googletest/googletest/include/gtest/gtest.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.