name string | code string | asm string | file string |
|---|---|---|---|
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
... | 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 = ... | 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_adde... | 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: " << Form... | 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,... | /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 # 0... | /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,... | 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
xor... | /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,... | 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
xor... | /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.... | 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... | /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,... | 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,... | /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,... | 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 ... | /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,... | 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
xor... | /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.... | 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... | /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,... | 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,... | /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_... | 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,... | 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, ... | /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: " << Form... | 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,... | /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: " << Form... | 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,... | /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: " << Form... | 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,... | /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,... | 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, ... | /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,... | 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
xor... | /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.... | 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
mo... | /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,... | 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 ... | /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,... | 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
mov... | /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... | /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,... | 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), %rc... | /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,... | 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 ... | /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,... | 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
mov... | /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,... | 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
xor... | /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,... | 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 0... | /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,... | 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
xor... | /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
... | /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 == nu... | 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 0x1... | /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... | /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 *s... | 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 ... | /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 ne... | 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
m... | /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_repor... | 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 ... | /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, %rd... | /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_
}
ret... | 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) {
... | 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,... | /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... | /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 '+':
... | 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... | /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 ... | 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,... | /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) {
... | 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)
le... | /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... | 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... | /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_expr... | 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 0x5c5... | /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 = sizeo... | 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
jm... | /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_trait... | AssertionResult IsSubstringImpl(
bool expected_to_be_substring,
const char* needle_expr, const char* haystack_expr,
const StringType& needle, const StringType& haystack) {
if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
return AssertionSuccess();
const bool is_wide_string = sizeo... | pushq %rbp
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 0x... | /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<cha... | 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... | /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 && IsU... | 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... | /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 AssertionFail... | 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 ... | /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
mov... | /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 = 0x6DB6DB6DB6DB6D... | /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_m... | 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 0x5... | /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
c... | /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 ... | /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_res... | 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... | /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)... | /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)... | /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... | /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.... | 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... | /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
pop... | /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 remin... | 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
mov... | /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... | 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, "[ ... | 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), %rs... | /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", coun... | 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 #... | /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_suit... | 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 0... | /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... | 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 # 0x681... | /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(),
FormatTest... | 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 %e... | /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 ... | 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(),
FormatTestSu... | 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 %e... | /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(... | /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 0x51... | /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)... | 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 %rb... | /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 %rb... | /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 '&'... | 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
... | /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... | /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_e... | 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 ... | /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 = "testcas... | 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 $0x... | /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 0... | /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 = ... | 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)
l... | /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... | 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
mo... | /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() << "="
<< "\"" << EscapeXmlA... | 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... | /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(&str... | 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 %rb... | /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... | 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_... | 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),... | /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 = "t... | 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... | /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... | 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)
lea... | /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(%... | /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... | 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 ... | /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(s... | 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)
m... | /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_s... | 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)
m... | /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 ch... | 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
m... | /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 =... | 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 # 0x685... | /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 != nullp... | 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... | /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
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.