idx int64 0 2.11M | name stringlengths 1 118k | code stringlengths 6 516k | asm stringlengths 21 4.64M | file stringlengths 39 143 | opt stringclasses 1 value | path stringlengths 20 133 |
|---|---|---|---|---|---|---|
11,000 | bool UnitTest::ArrayAreClose<float [2], float [2], float>(float const (&) [2], float const (&) [2], int, float const&) | bool ArrayAreClose(Expected const& expected, Actual const& actual, int const count, Tolerance const& tolerance)
{
bool equal = true;
for (int i = 0; i < count; ++i)
equal &= AreClose(expected[i], actual[i], tolerance);
return equal;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2bc26
movq -0x8(%rbp), %rdi
movslq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x2a960
andb $0x1, %al
movzbl %al, %ecx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2bbd2
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../Checks.h |
11,001 | void UnitTest::CheckArray2DClose<int [2][2], int [2][2], float>(UnitTest::TestResults&, int const (&) [2][2], int const (&) [2][2], int, int, float const&, UnitTest::TestDetails const&) | void CheckArray2DClose(TestResults& results, Expected const& expected, Actual const& actual,
int const rows, int const columns, Tolerance const& tolerance, TestDetails const& details)
{
bool equal = true;
for (int i = 0; i < rows; ++i)
equal &= ArrayAreClose(expected[i], actual[i], columns, tolerance);
if (!equal)
{
UnitTest::MemoryOutStream stream;
stream << "Expected [ ";
for (int expectedRow = 0; expectedRow < rows; ++expectedRow)
{
stream << "[ ";
for (int expectedColumn = 0; expectedColumn < columns; ++expectedColumn)
stream << expected[expectedRow][expectedColumn] << " ";
stream << "] ";
}
stream << "] +/- " << tolerance << " but was [ ";
for (int actualRow = 0; actualRow < rows; ++actualRow)
{
stream << "[ ";
for (int actualColumn = 0; actualColumn < columns; ++actualColumn)
stream << actual[actualRow][actualColumn] << " ";
stream << "] ";
}
stream << "]";
results.OnTestFailure(details, stream.GetText());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movb $0x1, -0x29(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2bcc8
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movl -0x20(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x2bf70
andb $0x1, %al
movzbl %al, %ecx
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2bc71
testb $0x1, -0x29(%rbp)
jne 0x2bf5b
leaq -0x1c8(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x1ab50
movq -0x1f0(%rbp), %rdi
leaq 0x35378(%rip), %rsi # 0x6106b
callq 0x15250
jmp 0x2bcfa
movl $0x0, -0x1d8(%rbp)
movl -0x1d8(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2bde1
leaq 0x3535a(%rip), %rsi # 0x61074
leaq -0x1c8(%rbp), %rdi
callq 0x15250
jmp 0x2bd28
movl $0x0, -0x1dc(%rbp)
movl -0x1dc(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x2bdb6
movq -0x10(%rbp), %rax
movslq -0x1d8(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movslq -0x1dc(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq -0x1c8(%rbp), %rdi
callq 0x15410
movq %rax, -0x1f8(%rbp)
jmp 0x2bd6b
movq -0x1f8(%rbp), %rdi
leaq 0x35303(%rip), %rsi # 0x6107c
callq 0x15250
jmp 0x2bd80
jmp 0x2bd82
movl -0x1dc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1dc(%rbp)
jmp 0x2bd32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x1abe0
jmp 0x2bf64
leaq 0x35b39(%rip), %rsi # 0x618f6
leaq -0x1c8(%rbp), %rdi
callq 0x15250
jmp 0x2bdcb
jmp 0x2bdcd
movl -0x1d8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d8(%rbp)
jmp 0x2bd04
leaq 0x3528f(%rip), %rsi # 0x61077
leaq -0x1c8(%rbp), %rdi
callq 0x15250
movq %rax, -0x200(%rbp)
jmp 0x2bdfd
movq -0x200(%rbp), %rdi
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
callq 0x151c0
movq %rax, -0x208(%rbp)
jmp 0x2be1a
movq -0x208(%rbp), %rdi
leaq 0x35805(%rip), %rsi # 0x6162d
callq 0x15250
jmp 0x2be2f
movl $0x0, -0x1e0(%rbp)
movl -0x1e0(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2bef3
leaq 0x35225(%rip), %rsi # 0x61074
leaq -0x1c8(%rbp), %rdi
callq 0x15250
jmp 0x2be5d
movl $0x0, -0x1e4(%rbp)
movl -0x1e4(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x2bec8
movq -0x18(%rbp), %rax
movslq -0x1e0(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movslq -0x1e4(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq -0x1c8(%rbp), %rdi
callq 0x15410
movq %rax, -0x210(%rbp)
jmp 0x2bea0
movq -0x210(%rbp), %rdi
leaq 0x351ce(%rip), %rsi # 0x6107c
callq 0x15250
jmp 0x2beb5
jmp 0x2beb7
movl -0x1e4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1e4(%rbp)
jmp 0x2be67
leaq 0x35a27(%rip), %rsi # 0x618f6
leaq -0x1c8(%rbp), %rdi
callq 0x15250
jmp 0x2bedd
jmp 0x2bedf
movl -0x1e0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1e0(%rbp)
jmp 0x2be39
leaq 0x35221(%rip), %rsi # 0x6111b
leaq -0x1c8(%rbp), %rdi
callq 0x15250
jmp 0x2bf08
movq -0x8(%rbp), %rax
movq %rax, -0x228(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x220(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x218(%rbp)
jmp 0x2bf33
movq -0x218(%rbp), %rdx
movq -0x220(%rbp), %rsi
movq -0x228(%rbp), %rdi
callq 0x5d9a0
jmp 0x2bf4f
leaq -0x1c8(%rbp), %rdi
callq 0x1abe0
addq $0x230, %rsp # imm = 0x230
popq %rbp
retq
movq -0x1d0(%rbp), %rdi
callq 0x15420
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../Checks.h |
11,002 | bool UnitTest::ArrayAreClose<int [2], int [2], float>(int const (&) [2], int const (&) [2], int, float const&) | bool ArrayAreClose(Expected const& expected, Actual const& actual, int const count, Tolerance const& tolerance)
{
bool equal = true;
for (int i = 0; i < count; ++i)
equal &= AreClose(expected[i], actual[i], tolerance);
return equal;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2bfe6
movq -0x8(%rbp), %rdi
movslq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x2ab40
andb $0x1, %al
movzbl %al, %ecx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2bf92
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../Checks.h |
11,003 | bool UnitTest::ArrayAreClose<float [2], float*, float>(float const (&) [2], float* const&, int, float const&) | bool ArrayAreClose(Expected const& expected, Actual const& actual, int const count, Tolerance const& tolerance)
{
bool equal = true;
for (int i = 0; i < count; ++i)
equal &= AreClose(expected[i], actual[i], tolerance);
return equal;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2c079
movq -0x8(%rbp), %rdi
movslq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movslq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x2a960
andb $0x1, %al
movzbl %al, %ecx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2c022
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../Checks.h |
11,004 | void UnitTest::CheckArray2DClose<float [2][2], float const* const*, float>(UnitTest::TestResults&, float const (&) [2][2], float const* const* const&, int, int, float const&, UnitTest::TestDetails const&) | void CheckArray2DClose(TestResults& results, Expected const& expected, Actual const& actual,
int const rows, int const columns, Tolerance const& tolerance, TestDetails const& details)
{
bool equal = true;
for (int i = 0; i < rows; ++i)
equal &= ArrayAreClose(expected[i], actual[i], columns, tolerance);
if (!equal)
{
UnitTest::MemoryOutStream stream;
stream << "Expected [ ";
for (int expectedRow = 0; expectedRow < rows; ++expectedRow)
{
stream << "[ ";
for (int expectedColumn = 0; expectedColumn < columns; ++expectedColumn)
stream << expected[expectedRow][expectedColumn] << " ";
stream << "] ";
}
stream << "] +/- " << tolerance << " but was [ ";
for (int actualRow = 0; actualRow < rows; ++actualRow)
{
stream << "[ ";
for (int actualColumn = 0; actualColumn < columns; ++actualColumn)
stream << actual[actualRow][actualColumn] << " ";
stream << "] ";
}
stream << "]";
results.OnTestFailure(details, stream.GetText());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movb $0x1, -0x29(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2c11b
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movslq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movl -0x20(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x2c3d0
andb $0x1, %al
movzbl %al, %ecx
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2c0c1
testb $0x1, -0x29(%rbp)
jne 0x2c3b5
leaq -0x1c8(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x1ab50
movq -0x1f0(%rbp), %rdi
leaq 0x34f25(%rip), %rsi # 0x6106b
callq 0x15250
jmp 0x2c14d
movl $0x0, -0x1d8(%rbp)
movl -0x1d8(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2c236
leaq 0x34f07(%rip), %rsi # 0x61074
leaq -0x1c8(%rbp), %rdi
callq 0x15250
jmp 0x2c17b
movl $0x0, -0x1dc(%rbp)
movl -0x1dc(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x2c20b
movq -0x10(%rbp), %rax
movslq -0x1d8(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movslq -0x1dc(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
leaq -0x1c8(%rbp), %rdi
callq 0x151c0
movq %rax, -0x1f8(%rbp)
jmp 0x2c1c0
movq -0x1f8(%rbp), %rdi
leaq 0x34eae(%rip), %rsi # 0x6107c
callq 0x15250
jmp 0x2c1d5
jmp 0x2c1d7
movl -0x1dc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1dc(%rbp)
jmp 0x2c185
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x1abe0
jmp 0x2c3be
leaq 0x356e4(%rip), %rsi # 0x618f6
leaq -0x1c8(%rbp), %rdi
callq 0x15250
jmp 0x2c220
jmp 0x2c222
movl -0x1d8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d8(%rbp)
jmp 0x2c157
leaq 0x34e3a(%rip), %rsi # 0x61077
leaq -0x1c8(%rbp), %rdi
callq 0x15250
movq %rax, -0x200(%rbp)
jmp 0x2c252
movq -0x200(%rbp), %rdi
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
callq 0x151c0
movq %rax, -0x208(%rbp)
jmp 0x2c26f
movq -0x208(%rbp), %rdi
leaq 0x353b0(%rip), %rsi # 0x6162d
callq 0x15250
jmp 0x2c284
movl $0x0, -0x1e0(%rbp)
movl -0x1e0(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2c34d
leaq 0x34dd0(%rip), %rsi # 0x61074
leaq -0x1c8(%rbp), %rdi
callq 0x15250
jmp 0x2c2b2
movl $0x0, -0x1e4(%rbp)
movl -0x1e4(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x2c322
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1e0(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1e4(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
leaq -0x1c8(%rbp), %rdi
callq 0x151c0
movq %rax, -0x210(%rbp)
jmp 0x2c2fa
movq -0x210(%rbp), %rdi
leaq 0x34d74(%rip), %rsi # 0x6107c
callq 0x15250
jmp 0x2c30f
jmp 0x2c311
movl -0x1e4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1e4(%rbp)
jmp 0x2c2bc
leaq 0x355cd(%rip), %rsi # 0x618f6
leaq -0x1c8(%rbp), %rdi
callq 0x15250
jmp 0x2c337
jmp 0x2c339
movl -0x1e0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1e0(%rbp)
jmp 0x2c28e
leaq 0x34dc7(%rip), %rsi # 0x6111b
leaq -0x1c8(%rbp), %rdi
callq 0x15250
jmp 0x2c362
movq -0x8(%rbp), %rax
movq %rax, -0x228(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x220(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x218(%rbp)
jmp 0x2c38d
movq -0x218(%rbp), %rdx
movq -0x220(%rbp), %rsi
movq -0x228(%rbp), %rdi
callq 0x5d9a0
jmp 0x2c3a9
leaq -0x1c8(%rbp), %rdi
callq 0x1abe0
addq $0x230, %rsp # imm = 0x230
popq %rbp
retq
movq -0x1d0(%rbp), %rdi
callq 0x15420
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../Checks.h |
11,005 | bool UnitTest::ArrayAreClose<float [2], float const*, float>(float const (&) [2], float const* const&, int, float const&) | bool ArrayAreClose(Expected const& expected, Actual const& actual, int const count, Tolerance const& tolerance)
{
bool equal = true;
for (int i = 0; i < count; ++i)
equal &= AreClose(expected[i], actual[i], tolerance);
return equal;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2c449
movq -0x8(%rbp), %rdi
movslq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movslq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x2a960
andb $0x1, %al
movzbl %al, %ecx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2c3f2
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../Checks.h |
11,006 | (anonymous namespace)::TestCheckEqualWithUnsignedLong::TestCheckEqualWithUnsignedLong() | TEST(CheckEqualWithUnsignedLong)
{
TestResults results;
unsigned long something = 2;
CHECK_EQUAL(something, something);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x36561(%rip), %rsi # 0x629e8
leaq 0x36575(%rip), %rcx # 0x62a03
movl $0xa, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x573b4(%rip), %rcx # 0x83858
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,007 | (anonymous namespace)::TestCheckEqualWithUnsignedLong::~TestCheckEqualWithUnsignedLong() | TEST(CheckEqualWithUnsignedLong)
{
TestResults results;
unsigned long something = 2;
CHECK_EQUAL(something, something);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,008 | (anonymous namespace)::TestCheckEqualsWithStringsFailsOnDifferentStrings::TestCheckEqualsWithStringsFailsOnDifferentStrings() | TEST(CheckEqualsWithStringsFailsOnDifferentStrings)
{
char txt1[] = "Hello";
char txt2[] = "Hallo";
TestResults results;
CheckEqual(results, txt1, txt2, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x365a3(%rip), %rsi # 0x62aaa
leaq 0x364f5(%rip), %rcx # 0x62a03
movl $0x11, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x57374(%rip), %rcx # 0x83898
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,009 | (anonymous namespace)::TestCheckEqualsWithStringsFailsOnDifferentStrings::~TestCheckEqualsWithStringsFailsOnDifferentStrings() | TEST(CheckEqualsWithStringsFailsOnDifferentStrings)
{
char txt1[] = "Hello";
char txt2[] = "Hallo";
TestResults results;
CheckEqual(results, txt1, txt2, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,010 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsNonConstNonConst::TestCheckEqualsWithStringsWorksOnContentsNonConstNonConst() | TEST(CheckEqualsWithStringsWorksOnContentsNonConstNonConst)
{
char const* const p1 = txt1;
char const* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x3659e(%rip), %rsi # 0x62b25
leaq 0x36475(%rip), %rcx # 0x62a03
movl $0x1d, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x57334(%rip), %rcx # 0x838d8
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,011 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsNonConstNonConst::~TestCheckEqualsWithStringsWorksOnContentsNonConstNonConst() | TEST(CheckEqualsWithStringsWorksOnContentsNonConstNonConst)
{
char const* const p1 = txt1;
char const* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,012 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsConstConst::TestCheckEqualsWithStringsWorksOnContentsConstConst() | TEST(CheckEqualsWithStringsWorksOnContentsConstConst)
{
char* const p1 = txt1;
char* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x36595(%rip), %rsi # 0x62b9c
leaq 0x363f5(%rip), %rcx # 0x62a03
movl $0x26, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x572f4(%rip), %rcx # 0x83918
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,013 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsConstConst::~TestCheckEqualsWithStringsWorksOnContentsConstConst() | TEST(CheckEqualsWithStringsWorksOnContentsConstConst)
{
char* const p1 = txt1;
char* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,014 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsNonConstConst::TestCheckEqualsWithStringsWorksOnContentsNonConstConst() | TEST(CheckEqualsWithStringsWorksOnContentsNonConstConst)
{
char* const p1 = txt1;
char const* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x36545(%rip), %rsi # 0x62bcc
leaq 0x36375(%rip), %rcx # 0x62a03
movl $0x2f, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x572b4(%rip), %rcx # 0x83958
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,015 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsNonConstConst::~TestCheckEqualsWithStringsWorksOnContentsNonConstConst() | TEST(CheckEqualsWithStringsWorksOnContentsNonConstConst)
{
char* const p1 = txt1;
char const* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,016 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsConstNonConst::TestCheckEqualsWithStringsWorksOnContentsConstNonConst() | TEST(CheckEqualsWithStringsWorksOnContentsConstNonConst)
{
char const* const p1 = txt1;
char* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x364f8(%rip), %rsi # 0x62bff
leaq 0x362f5(%rip), %rcx # 0x62a03
movl $0x38, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x57274(%rip), %rcx # 0x83998
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,017 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsConstNonConst::~TestCheckEqualsWithStringsWorksOnContentsConstNonConst() | TEST(CheckEqualsWithStringsWorksOnContentsConstNonConst)
{
char const* const p1 = txt1;
char* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,018 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsWithALiteral::TestCheckEqualsWithStringsWorksOnContentsWithALiteral() | TEST(CheckEqualsWithStringsWorksOnContentsWithALiteral)
{
char const* const p1 = txt1;
TestResults results;
CheckEqual(results, "Hello", p1, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x364ab(%rip), %rsi # 0x62c32
leaq 0x36275(%rip), %rcx # 0x62a03
movl $0x41, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x57234(%rip), %rcx # 0x839d8
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,019 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsWithALiteral::~TestCheckEqualsWithStringsWorksOnContentsWithALiteral() | TEST(CheckEqualsWithStringsWorksOnContentsWithALiteral)
{
char const* const p1 = txt1;
TestResults results;
CheckEqual(results, "Hello", p1, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,020 | (anonymous namespace)::TestCheckEqualFailureIncludesCheckExpectedAndActual::TestCheckEqualFailureIncludesCheckExpectedAndActual() | TEST(CheckEqualFailureIncludesCheckExpectedAndActual)
{
RecordingReporter reporter;
TestResults results(&reporter);
const int something = 2;
CheckEqual(results, 1, something, TestDetails("", "", "", 0));
using namespace std;
CHECK(strstr(reporter.lastFailedMessage, "xpected 1"));
CHECK(strstr(reporter.lastFailedMessage, "was 2"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x3645d(%rip), %rsi # 0x62c64
leaq 0x361f5(%rip), %rcx # 0x62a03
movl $0x49, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x571f4(%rip), %rcx # 0x83a18
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,021 | (anonymous namespace)::TestCheckEqualFailureIncludesCheckExpectedAndActual::~TestCheckEqualFailureIncludesCheckExpectedAndActual() | TEST(CheckEqualFailureIncludesCheckExpectedAndActual)
{
RecordingReporter reporter;
TestResults results(&reporter);
const int something = 2;
CheckEqual(results, 1, something, TestDetails("", "", "", 0));
using namespace std;
CHECK(strstr(reporter.lastFailedMessage, "xpected 1"));
CHECK(strstr(reporter.lastFailedMessage, "was 2"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,022 | (anonymous namespace)::TestCheckEqualFailureIncludesDetails::TestCheckEqualFailureIncludesDetails() | TEST(CheckEqualFailureIncludesDetails)
{
RecordingReporter reporter;
TestResults results(&reporter);
TestDetails const details("mytest", "mysuite", "file.h", 101);
CheckEqual(results, 1, 2, details);
CHECK_EQUAL("mytest", reporter.lastFailedTest);
CHECK_EQUAL("mysuite", reporter.lastFailedSuite);
CHECK_EQUAL("file.h", reporter.lastFailedFile);
CHECK_EQUAL(101, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x3650b(%rip), %rsi # 0x62d92
leaq 0x36175(%rip), %rcx # 0x62a03
movl $0x55, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x571b4(%rip), %rcx # 0x83a58
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,023 | (anonymous namespace)::TestCheckEqualFailureIncludesDetails::~TestCheckEqualFailureIncludesDetails() | TEST(CheckEqualFailureIncludesDetails)
{
RecordingReporter reporter;
TestResults results(&reporter);
TestDetails const details("mytest", "mysuite", "file.h", 101);
CheckEqual(results, 1, 2, details);
CHECK_EQUAL("mytest", reporter.lastFailedTest);
CHECK_EQUAL("mysuite", reporter.lastFailedSuite);
CHECK_EQUAL("file.h", reporter.lastFailedFile);
CHECK_EQUAL(101, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,024 | (anonymous namespace)::TestCheckCloseTrue::TestCheckCloseTrue() | TEST(CheckCloseTrue)
{
TestResults results;
CheckClose(results, 3.001f, 3.0f, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x365d7(%rip), %rsi # 0x62ede
leaq 0x360f5(%rip), %rcx # 0x62a03
movl $0x63, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x57174(%rip), %rcx # 0x83a98
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,025 | (anonymous namespace)::TestCheckCloseTrue::~TestCheckCloseTrue() | TEST(CheckCloseTrue)
{
TestResults results;
CheckClose(results, 3.001f, 3.0f, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,026 | (anonymous namespace)::TestCheckCloseFalse::TestCheckCloseFalse() | TEST(CheckCloseFalse)
{
TestResults results;
CheckClose(results, 3.12f, 3.0f, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x36566(%rip), %rsi # 0x62eed
leaq 0x36075(%rip), %rcx # 0x62a03
movl $0x6a, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x57134(%rip), %rcx # 0x83ad8
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,027 | (anonymous namespace)::TestCheckCloseFalse::~TestCheckCloseFalse() | TEST(CheckCloseFalse)
{
TestResults results;
CheckClose(results, 3.12f, 3.0f, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,028 | (anonymous namespace)::TestCheckCloseWithZeroEpsilonWorksForSameNumber::TestCheckCloseWithZeroEpsilonWorksForSameNumber() | TEST(CheckCloseWithZeroEpsilonWorksForSameNumber)
{
TestResults results;
CheckClose(results, 0.1f, 0.1f, 0, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x364f6(%rip), %rsi # 0x62efd
leaq 0x35ff5(%rip), %rcx # 0x62a03
movl $0x71, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x570f4(%rip), %rcx # 0x83b18
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,029 | (anonymous namespace)::TestCheckCloseWithZeroEpsilonWorksForSameNumber::~TestCheckCloseWithZeroEpsilonWorksForSameNumber() | TEST(CheckCloseWithZeroEpsilonWorksForSameNumber)
{
TestResults results;
CheckClose(results, 0.1f, 0.1f, 0, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,030 | (anonymous namespace)::TestCheckCloseWithNaNFails::TestCheckCloseWithNaNFails() | TEST(CheckCloseWithNaNFails)
{
union
{
unsigned int bitpattern;
float nan;
};
bitpattern = 0xFFFFFFFF;
TestResults results;
CheckClose(results, 3.0f, nan, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x364a2(%rip), %rsi # 0x62f29
leaq 0x35f75(%rip), %rcx # 0x62a03
movl $0x78, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x570b4(%rip), %rcx # 0x83b58
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,031 | (anonymous namespace)::TestCheckCloseWithNaNFails::~TestCheckCloseWithNaNFails() | TEST(CheckCloseWithNaNFails)
{
union
{
unsigned int bitpattern;
float nan;
};
bitpattern = 0xFFFFFFFF;
TestResults results;
CheckClose(results, 3.0f, nan, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,032 | (anonymous namespace)::TestCheckCloseWithNaNAgainstItselfFails::TestCheckCloseWithNaNAgainstItselfFails() | TEST(CheckCloseWithNaNAgainstItselfFails)
{
union
{
unsigned int bitpattern;
float nan;
};
bitpattern = 0xFFFFFFFF;
TestResults results;
CheckClose(results, nan, nan, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x36439(%rip), %rsi # 0x62f40
leaq 0x35ef5(%rip), %rcx # 0x62a03
movl $0x85, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x57074(%rip), %rcx # 0x83b98
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,033 | (anonymous namespace)::TestCheckCloseWithNaNAgainstItselfFails::~TestCheckCloseWithNaNAgainstItselfFails() | TEST(CheckCloseWithNaNAgainstItselfFails)
{
union
{
unsigned int bitpattern;
float nan;
};
bitpattern = 0xFFFFFFFF;
TestResults results;
CheckClose(results, nan, nan, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,034 | (anonymous namespace)::TestCheckCloseFailureIncludesCheckExpectedAndActual::TestCheckCloseFailureIncludesCheckExpectedAndActual() | TEST(CheckCloseFailureIncludesCheckExpectedAndActual)
{
RecordingReporter reporter;
TestResults results(&reporter);
const float expected = 0.9f;
const float actual = 1.1f;
CheckClose(results, expected, actual, 0.01f, TestDetails("", "", "", 0));
using namespace std;
CHECK(strstr(reporter.lastFailedMessage, "xpected 0.9"));
CHECK(strstr(reporter.lastFailedMessage, "was 1.1"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x363dd(%rip), %rsi # 0x62f64
leaq 0x35e75(%rip), %rcx # 0x62a03
movl $0x92, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x57034(%rip), %rcx # 0x83bd8
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,035 | (anonymous namespace)::TestCheckCloseFailureIncludesCheckExpectedAndActual::~TestCheckCloseFailureIncludesCheckExpectedAndActual() | TEST(CheckCloseFailureIncludesCheckExpectedAndActual)
{
RecordingReporter reporter;
TestResults results(&reporter);
const float expected = 0.9f;
const float actual = 1.1f;
CheckClose(results, expected, actual, 0.01f, TestDetails("", "", "", 0));
using namespace std;
CHECK(strstr(reporter.lastFailedMessage, "xpected 0.9"));
CHECK(strstr(reporter.lastFailedMessage, "was 1.1"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,036 | (anonymous namespace)::TestCheckCloseFailureIncludesTolerance::TestCheckCloseFailureIncludesTolerance() | TEST(CheckCloseFailureIncludesTolerance)
{
RecordingReporter reporter;
TestResults results(&reporter);
CheckClose(results, 2, 3, 0.01f, TestDetails("", "", "", 0));
using namespace std;
CHECK(strstr(reporter.lastFailedMessage, "0.01"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x3649d(%rip), %rsi # 0x630a4
leaq 0x35df5(%rip), %rcx # 0x62a03
movl $0x9f, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x56ff4(%rip), %rcx # 0x83c18
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,037 | (anonymous namespace)::TestCheckCloseFailureIncludesTolerance::~TestCheckCloseFailureIncludesTolerance() | TEST(CheckCloseFailureIncludesTolerance)
{
RecordingReporter reporter;
TestResults results(&reporter);
CheckClose(results, 2, 3, 0.01f, TestDetails("", "", "", 0));
using namespace std;
CHECK(strstr(reporter.lastFailedMessage, "0.01"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,038 | (anonymous namespace)::TestCheckCloseFailureIncludesDetails::TestCheckCloseFailureIncludesDetails() | TEST(CheckCloseFailureIncludesDetails)
{
RecordingReporter reporter;
TestResults results(&reporter);
TestDetails const details("mytest", "mysuite", "header.h", 10);
CheckClose(results, 2, 3, 0.01f, details);
CHECK_EQUAL("mytest", reporter.lastFailedTest);
CHECK_EQUAL("mysuite", reporter.lastFailedSuite);
CHECK_EQUAL("header.h", reporter.lastFailedFile);
CHECK_EQUAL(10, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x36440(%rip), %rsi # 0x630c7
leaq 0x35d75(%rip), %rcx # 0x62a03
movl $0xa9, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x56fb4(%rip), %rcx # 0x83c58
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,039 | (anonymous namespace)::TestCheckCloseFailureIncludesDetails::~TestCheckCloseFailureIncludesDetails() | TEST(CheckCloseFailureIncludesDetails)
{
RecordingReporter reporter;
TestResults results(&reporter);
TestDetails const details("mytest", "mysuite", "header.h", 10);
CheckClose(results, 2, 3, 0.01f, details);
CHECK_EQUAL("mytest", reporter.lastFailedTest);
CHECK_EQUAL("mysuite", reporter.lastFailedSuite);
CHECK_EQUAL("header.h", reporter.lastFailedFile);
CHECK_EQUAL(10, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,040 | (anonymous namespace)::TestCheckArrayEqualTrue::TestCheckArrayEqualTrue() | TEST(CheckArrayEqualTrue)
{
TestResults results;
int const array[3] = { 1, 2, 3 };
CheckArrayEqual(results, array, array, 3, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x36472(%rip), %rsi # 0x63179
leaq 0x35cf5(%rip), %rcx # 0x62a03
movl $0xb8, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x56f74(%rip), %rcx # 0x83c98
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,041 | (anonymous namespace)::TestCheckArrayEqualTrue::~TestCheckArrayEqualTrue() | TEST(CheckArrayEqualTrue)
{
TestResults results;
int const array[3] = { 1, 2, 3 };
CheckArrayEqual(results, array, array, 3, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,042 | (anonymous namespace)::TestCheckArrayEqualFalse::TestCheckArrayEqualFalse() | TEST(CheckArrayEqualFalse)
{
TestResults results;
int const array1[3] = { 1, 2, 3 };
int const array2[3] = { 1, 2, 2 };
CheckArrayEqual(results, array1, array2, 3, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x36406(%rip), %rsi # 0x6318d
leaq 0x35c75(%rip), %rcx # 0x62a03
movl $0xc1, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x56f34(%rip), %rcx # 0x83cd8
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,043 | (anonymous namespace)::TestCheckArrayEqualFalse::~TestCheckArrayEqualFalse() | TEST(CheckArrayEqualFalse)
{
TestResults results;
int const array1[3] = { 1, 2, 3 };
int const array2[3] = { 1, 2, 2 };
CheckArrayEqual(results, array1, array2, 3, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,044 | (anonymous namespace)::TestCheckArrayCloseTrue::TestCheckArrayCloseTrue() | TEST(CheckArrayCloseTrue)
{
TestResults results;
float const array1[3] = { 1.0f, 1.5f, 2.0f };
float const array2[3] = { 1.01f, 1.51f, 2.01f };
CheckArrayClose(results, array1, array2, 3, 0.02f, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x3639b(%rip), %rsi # 0x631a2
leaq 0x35bf5(%rip), %rcx # 0x62a03
movl $0xcb, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x56ef4(%rip), %rcx # 0x83d18
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,045 | (anonymous namespace)::TestCheckArrayCloseTrue::~TestCheckArrayCloseTrue() | TEST(CheckArrayCloseTrue)
{
TestResults results;
float const array1[3] = { 1.0f, 1.5f, 2.0f };
float const array2[3] = { 1.01f, 1.51f, 2.01f };
CheckArrayClose(results, array1, array2, 3, 0.02f, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,046 | (anonymous namespace)::TestCheckArrayCloseFalse::TestCheckArrayCloseFalse() | TEST(CheckArrayCloseFalse)
{
TestResults results;
float const array1[3] = { 1.0f, 1.5f, 2.0f };
float const array2[3] = { 1.01f, 1.51f, 2.01f };
CheckArrayClose(results, array1, array2, 3, 0.001f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x3632f(%rip), %rsi # 0x631b6
leaq 0x35b75(%rip), %rcx # 0x62a03
movl $0xd5, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x56eb4(%rip), %rcx # 0x83d58
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,047 | (anonymous namespace)::TestCheckArrayCloseFalse::~TestCheckArrayCloseFalse() | TEST(CheckArrayCloseFalse)
{
TestResults results;
float const array1[3] = { 1.0f, 1.5f, 2.0f };
float const array2[3] = { 1.01f, 1.51f, 2.01f };
CheckArrayClose(results, array1, array2, 3, 0.001f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,048 | (anonymous namespace)::TestCheckArrayCloseFailureIncludesDetails::TestCheckArrayCloseFailureIncludesDetails() | TEST(CheckArrayCloseFailureIncludesDetails)
{
RecordingReporter reporter;
TestResults results(&reporter);
TestDetails const details("arrayCloseTest", "arrayCloseSuite", "file", 1337);
float const array1[3] = { 1.0f, 1.5f, 2.0f };
float const array2[3] = { 1.01f, 1.51f, 2.01f };
CheckArrayClose(results, array1, array2, 3, 0.001f, details);
CHECK_EQUAL("arrayCloseTest", reporter.lastFailedTest);
CHECK_EQUAL("arrayCloseSuite", reporter.lastFailedSuite);
CHECK_EQUAL("file", reporter.lastFailedFile);
CHECK_EQUAL(1337, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x362c4(%rip), %rsi # 0x631cb
leaq 0x35af5(%rip), %rcx # 0x62a03
movl $0xdf, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x56e74(%rip), %rcx # 0x83d98
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,049 | (anonymous namespace)::TestCheckArrayCloseFailureIncludesDetails::~TestCheckArrayCloseFailureIncludesDetails() | TEST(CheckArrayCloseFailureIncludesDetails)
{
RecordingReporter reporter;
TestResults results(&reporter);
TestDetails const details("arrayCloseTest", "arrayCloseSuite", "file", 1337);
float const array1[3] = { 1.0f, 1.5f, 2.0f };
float const array2[3] = { 1.01f, 1.51f, 2.01f };
CheckArrayClose(results, array1, array2, 3, 0.001f, details);
CHECK_EQUAL("arrayCloseTest", reporter.lastFailedTest);
CHECK_EQUAL("arrayCloseSuite", reporter.lastFailedSuite);
CHECK_EQUAL("file", reporter.lastFailedFile);
CHECK_EQUAL(1337, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,050 | (anonymous namespace)::TestCheckArray2DCloseTrue::TestCheckArray2DCloseTrue() | TEST(CheckArray2DCloseTrue)
{
TestResults results;
float const array1[3][3] = { { 1.0f, 1.5f, 2.0f },
{ 2.0f, 2.5f, 3.0f },
{ 3.0f, 3.5f, 4.0f } };
float const array2[3][3] = { { 1.01f, 1.51f, 2.01f },
{ 2.01f, 2.51f, 3.01f },
{ 3.01f, 3.51f, 4.01f } };
CheckArray2DClose(results, array1, array2, 3, 3, 0.02f, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x362f5(%rip), %rsi # 0x6327c
leaq 0x35a75(%rip), %rcx # 0x62a03
movl $0xf0, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x56e34(%rip), %rcx # 0x83dd8
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,051 | (anonymous namespace)::TestCheckArray2DCloseTrue::~TestCheckArray2DCloseTrue() | TEST(CheckArray2DCloseTrue)
{
TestResults results;
float const array1[3][3] = { { 1.0f, 1.5f, 2.0f },
{ 2.0f, 2.5f, 3.0f },
{ 3.0f, 3.5f, 4.0f } };
float const array2[3][3] = { { 1.01f, 1.51f, 2.01f },
{ 2.01f, 2.51f, 3.01f },
{ 3.01f, 3.51f, 4.01f } };
CheckArray2DClose(results, array1, array2, 3, 3, 0.02f, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,052 | (anonymous namespace)::TestCheckArray2DCloseFalse::TestCheckArray2DCloseFalse() | TEST(CheckArray2DCloseFalse)
{
TestResults results;
float const array1[3][3] = { { 1.0f, 1.5f, 2.0f },
{ 2.0f, 2.5f, 3.0f },
{ 3.0f, 3.5f, 4.0f } };
float const array2[3][3] = { { 1.01f, 1.51f, 2.01f },
{ 2.01f, 2.51f, 3.01f },
{ 3.01f, 3.51f, 4.01f } };
CheckArray2DClose(results, array1, array2, 3, 3, 0.001f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x3628b(%rip), %rsi # 0x63292
leaq 0x359f5(%rip), %rcx # 0x62a03
movl $0xfe, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x56df4(%rip), %rcx # 0x83e18
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,053 | (anonymous namespace)::TestCheckArray2DCloseFalse::~TestCheckArray2DCloseFalse() | TEST(CheckArray2DCloseFalse)
{
TestResults results;
float const array1[3][3] = { { 1.0f, 1.5f, 2.0f },
{ 2.0f, 2.5f, 3.0f },
{ 3.0f, 3.5f, 4.0f } };
float const array2[3][3] = { { 1.01f, 1.51f, 2.01f },
{ 2.01f, 2.51f, 3.01f },
{ 3.01f, 3.51f, 4.01f } };
CheckArray2DClose(results, array1, array2, 3, 3, 0.001f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,054 | (anonymous namespace)::TestCheckCloseWithDoublesSucceeds::TestCheckCloseWithDoublesSucceeds() | TEST(CheckCloseWithDoublesSucceeds)
{
CHECK_CLOSE(0.5, 0.5, 0.0001);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x36222(%rip), %rsi # 0x632a9
leaq 0x35975(%rip), %rcx # 0x62a03
movl $0x10c, %r8d # imm = 0x10C
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x56db4(%rip), %rcx # 0x83e58
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,055 | (anonymous namespace)::TestCheckCloseWithDoublesSucceeds::~TestCheckCloseWithDoublesSucceeds() | TEST(CheckCloseWithDoublesSucceeds)
{
CHECK_CLOSE(0.5, 0.5, 0.0001);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,056 | (anonymous namespace)::TestCheckArray2DCloseFailureIncludesDetails::TestCheckArray2DCloseFailureIncludesDetails() | TEST(CheckArray2DCloseFailureIncludesDetails)
{
RecordingReporter reporter;
TestResults results(&reporter);
TestDetails const details("array2DCloseTest", "array2DCloseSuite", "file", 1234);
float const array1[3][3] = { { 1.0f, 1.5f, 2.0f },
{ 2.0f, 2.5f, 3.0f },
{ 3.0f, 3.5f, 4.0f } };
float const array2[3][3] = { { 1.01f, 1.51f, 2.01f },
{ 2.01f, 2.51f, 3.01f },
{ 3.01f, 3.51f, 4.01f } };
CheckArray2DClose(results, array1, array2, 3, 3, 0.001f, details);
CHECK_EQUAL("array2DCloseTest", reporter.lastFailedTest);
CHECK_EQUAL("array2DCloseSuite", reporter.lastFailedSuite);
CHECK_EQUAL("file", reporter.lastFailedFile);
CHECK_EQUAL(1234, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x361ed(%rip), %rsi # 0x632f4
leaq 0x358f5(%rip), %rcx # 0x62a03
movl $0x111, %r8d # imm = 0x111
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x56d74(%rip), %rcx # 0x83e98
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,057 | (anonymous namespace)::TestCheckArray2DCloseFailureIncludesDetails::~TestCheckArray2DCloseFailureIncludesDetails() | TEST(CheckArray2DCloseFailureIncludesDetails)
{
RecordingReporter reporter;
TestResults results(&reporter);
TestDetails const details("array2DCloseTest", "array2DCloseSuite", "file", 1234);
float const array1[3][3] = { { 1.0f, 1.5f, 2.0f },
{ 2.0f, 2.5f, 3.0f },
{ 3.0f, 3.5f, 4.0f } };
float const array2[3][3] = { { 1.01f, 1.51f, 2.01f },
{ 2.01f, 2.51f, 3.01f },
{ 3.01f, 3.51f, 4.01f } };
CheckArray2DClose(results, array1, array2, 3, 3, 0.001f, details);
CHECK_EQUAL("array2DCloseTest", reporter.lastFailedTest);
CHECK_EQUAL("array2DCloseSuite", reporter.lastFailedSuite);
CHECK_EQUAL("file", reporter.lastFailedFile);
CHECK_EQUAL(1234, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,058 | (anonymous namespace)::TestCheckEqualWithUnsignedLong::~TestCheckEqualWithUnsignedLong() | TEST(CheckEqualWithUnsignedLong)
{
TestResults results;
unsigned long something = 2;
CHECK_EQUAL(something, something);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2c4c0
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,059 | (anonymous namespace)::TestCheckEqualWithUnsignedLong::RunImpl() const | TEST(CheckEqualWithUnsignedLong)
{
TestResults results;
unsigned long something = 2;
CHECK_EQUAL(something, something);
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
movq $0x2, -0x28(%rbp)
callq 0x5b060
movq %rax, -0x80(%rbp)
jmp 0x2d1bf
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
callq 0x5b070
movq %rax, -0x88(%rbp)
jmp 0x2d1db
movq -0x88(%rbp), %rax
movq (%rax), %rsi
leaq -0x58(%rbp), %rdi
movl $0xe, %edx
callq 0x5d7c0
jmp 0x2d1f5
movq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rdx
leaq -0x58(%rbp), %rcx
movq %rdx, %rsi
callq 0x31700
jmp 0x2d20e
jmp 0x2d28a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x98(%rbp)
jmp 0x2d233
movq -0x98(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
callq 0x5b070
movq %rax, -0xa0(%rbp)
jmp 0x2d252
movq -0xa0(%rbp), %rax
movq (%rax), %rsi
leaq -0x78(%rbp), %rdi
movl $0xe, %edx
callq 0x5d7c0
jmp 0x2d26c
movq -0xa8(%rbp), %rdi
leaq 0x357f7(%rip), %rdx # 0x62a71
leaq -0x78(%rbp), %rsi
callq 0x5d9a0
jmp 0x2d285
callq 0x153e0
jmp 0x2d28c
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x153e0
jmp 0x2d2a8
jmp 0x2d2aa
movq -0x30(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,060 | (anonymous namespace)::TestCheckEqualsWithStringsFailsOnDifferentStrings::~TestCheckEqualsWithStringsFailsOnDifferentStrings() | TEST(CheckEqualsWithStringsFailsOnDifferentStrings)
{
char txt1[] = "Hello";
char txt2[] = "Hallo";
TestResults results;
CheckEqual(results, txt1, txt2, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2c540
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,061 | (anonymous namespace)::TestCheckEqualsWithStringsFailsOnDifferentStrings::RunImpl() const | TEST(CheckEqualsWithStringsFailsOnDifferentStrings)
{
char txt1[] = "Hello";
char txt2[] = "Hallo";
TestResults results;
CheckEqual(results, txt1, txt2, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl 0x357d3(%rip), %eax # 0x62ad8
movl %eax, -0xe(%rbp)
movw 0x357cd(%rip), %ax # 0x62adc
movw %ax, -0xa(%rbp)
movl 0x357c5(%rip), %eax # 0x62ade
movl %eax, -0x14(%rbp)
movw 0x357bf(%rip), %ax # 0x62ae2
movw %ax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
leaq -0xe(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x3cb03(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rcx
callq 0x5afa0
callq 0x5b060
movq %rax, -0xc0(%rbp)
jmp 0x2d38c
movq -0xc0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd0(%rbp)
movl $0x1, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5da90
movl %eax, -0xc4(%rbp)
jmp 0x2d3b5
movl -0xc4(%rbp), %eax
movl %eax, -0x64(%rbp)
callq 0x5b070
movq %rax, -0xd8(%rbp)
jmp 0x2d3cc
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
leaq -0x88(%rbp), %rdi
movl $0x17, %edx
callq 0x5d7c0
jmp 0x2d3e9
movq -0xd0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x64(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1aa10
jmp 0x2d406
jmp 0x2d48b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xe0(%rbp)
jmp 0x2d42e
movq -0xe0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xf0(%rbp)
callq 0x5b070
movq %rax, -0xe8(%rbp)
jmp 0x2d44d
movq -0xe8(%rbp), %rax
movq (%rax), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x17, %edx
callq 0x5d7c0
jmp 0x2d46a
movq -0xf0(%rbp), %rdi
leaq 0x3566c(%rip), %rdx # 0x62ae4
leaq -0xa8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2d486
callq 0x153e0
jmp 0x2d48d
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x153e0
jmp 0x2d4a9
jmp 0x2d4ab
movq -0x58(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,062 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsNonConstNonConst::~TestCheckEqualsWithStringsWorksOnContentsNonConstNonConst() | TEST(CheckEqualsWithStringsWorksOnContentsNonConstNonConst)
{
char const* const p1 = txt1;
char const* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2c5c0
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,063 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsNonConstNonConst::RunImpl() const | TEST(CheckEqualsWithStringsWorksOnContentsNonConstNonConst)
{
char const* const p1 = txt1;
char const* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x58d7a(%rip), %rax # 0x86280
movq %rax, -0x10(%rbp)
leaq 0x58d75(%rip), %rax # 0x86286
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
leaq -0x50(%rbp), %rdi
leaq 0x3c92b(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
leaq -0x30(%rbp), %rdi
leaq 0x58d3a(%rip), %rsi # 0x86280
leaq 0x58d39(%rip), %rdx # 0x86286
leaq -0x50(%rbp), %rcx
callq 0x5ae20
callq 0x5b060
movq %rax, -0xb0(%rbp)
jmp 0x2d564
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movl $0x0, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5da90
movl %eax, -0xb4(%rbp)
jmp 0x2d58d
movl -0xb4(%rbp), %eax
movl %eax, -0x64(%rbp)
callq 0x5b070
movq %rax, -0xc8(%rbp)
jmp 0x2d5a4
movq -0xc8(%rbp), %rax
movq (%rax), %rsi
leaq -0x88(%rbp), %rdi
movl $0x23, %edx
callq 0x5d7c0
jmp 0x2d5c1
movq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x64(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1aa10
jmp 0x2d5de
jmp 0x2d663
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xd0(%rbp)
jmp 0x2d606
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
callq 0x5b070
movq %rax, -0xd8(%rbp)
jmp 0x2d625
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x23, %edx
callq 0x5d7c0
jmp 0x2d642
movq -0xe0(%rbp), %rdi
leaq 0x3550b(%rip), %rdx # 0x62b5b
leaq -0xa8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2d65e
callq 0x153e0
jmp 0x2d665
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x153e0
jmp 0x2d681
jmp 0x2d683
movq -0x58(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,064 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsConstConst::~TestCheckEqualsWithStringsWorksOnContentsConstConst() | TEST(CheckEqualsWithStringsWorksOnContentsConstConst)
{
char* const p1 = txt1;
char* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2c640
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,065 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsConstConst::RunImpl() const | TEST(CheckEqualsWithStringsWorksOnContentsConstConst)
{
char* const p1 = txt1;
char* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x58b9a(%rip), %rax # 0x86280
movq %rax, -0x10(%rbp)
leaq 0x58b95(%rip), %rax # 0x86286
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
leaq -0x50(%rbp), %rdi
leaq 0x3c74b(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
leaq -0x30(%rbp), %rdi
leaq 0x58b5a(%rip), %rsi # 0x86280
leaq 0x58b59(%rip), %rdx # 0x86286
leaq -0x50(%rbp), %rcx
callq 0x5afa0
callq 0x5b060
movq %rax, -0xb0(%rbp)
jmp 0x2d744
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movl $0x0, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5da90
movl %eax, -0xb4(%rbp)
jmp 0x2d76d
movl -0xb4(%rbp), %eax
movl %eax, -0x64(%rbp)
callq 0x5b070
movq %rax, -0xc8(%rbp)
jmp 0x2d784
movq -0xc8(%rbp), %rax
movq (%rax), %rsi
leaq -0x88(%rbp), %rdi
movl $0x2c, %edx
callq 0x5d7c0
jmp 0x2d7a1
movq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x64(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1aa10
jmp 0x2d7be
jmp 0x2d843
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xd0(%rbp)
jmp 0x2d7e6
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
callq 0x5b070
movq %rax, -0xd8(%rbp)
jmp 0x2d805
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x2c, %edx
callq 0x5d7c0
jmp 0x2d822
movq -0xe0(%rbp), %rdi
leaq 0x3532b(%rip), %rdx # 0x62b5b
leaq -0xa8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2d83e
callq 0x153e0
jmp 0x2d845
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x153e0
jmp 0x2d861
jmp 0x2d863
movq -0x58(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,066 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsNonConstConst::~TestCheckEqualsWithStringsWorksOnContentsNonConstConst() | TEST(CheckEqualsWithStringsWorksOnContentsNonConstConst)
{
char* const p1 = txt1;
char const* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2c6c0
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,067 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsNonConstConst::RunImpl() const | TEST(CheckEqualsWithStringsWorksOnContentsNonConstConst)
{
char* const p1 = txt1;
char const* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x589ba(%rip), %rax # 0x86280
movq %rax, -0x10(%rbp)
leaq 0x589b5(%rip), %rax # 0x86286
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
leaq -0x50(%rbp), %rdi
leaq 0x3c56b(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
leaq -0x30(%rbp), %rdi
leaq 0x5897a(%rip), %rsi # 0x86280
leaq 0x58979(%rip), %rdx # 0x86286
leaq -0x50(%rbp), %rcx
callq 0x5afe0
callq 0x5b060
movq %rax, -0xb0(%rbp)
jmp 0x2d924
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movl $0x0, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5da90
movl %eax, -0xb4(%rbp)
jmp 0x2d94d
movl -0xb4(%rbp), %eax
movl %eax, -0x64(%rbp)
callq 0x5b070
movq %rax, -0xc8(%rbp)
jmp 0x2d964
movq -0xc8(%rbp), %rax
movq (%rax), %rsi
leaq -0x88(%rbp), %rdi
movl $0x35, %edx
callq 0x5d7c0
jmp 0x2d981
movq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x64(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1aa10
jmp 0x2d99e
jmp 0x2da23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xd0(%rbp)
jmp 0x2d9c6
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
callq 0x5b070
movq %rax, -0xd8(%rbp)
jmp 0x2d9e5
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x35, %edx
callq 0x5d7c0
jmp 0x2da02
movq -0xe0(%rbp), %rdi
leaq 0x3514b(%rip), %rdx # 0x62b5b
leaq -0xa8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2da1e
callq 0x153e0
jmp 0x2da25
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x153e0
jmp 0x2da41
jmp 0x2da43
movq -0x58(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,068 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsConstNonConst::~TestCheckEqualsWithStringsWorksOnContentsConstNonConst() | TEST(CheckEqualsWithStringsWorksOnContentsConstNonConst)
{
char const* const p1 = txt1;
char* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2c740
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,069 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsConstNonConst::RunImpl() const | TEST(CheckEqualsWithStringsWorksOnContentsConstNonConst)
{
char const* const p1 = txt1;
char* const p2 = txt2;
TestResults results;
CheckEqual(results, p1, p2, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x587da(%rip), %rax # 0x86280
movq %rax, -0x10(%rbp)
leaq 0x587d5(%rip), %rax # 0x86286
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
leaq -0x50(%rbp), %rdi
leaq 0x3c38b(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
leaq -0x30(%rbp), %rdi
leaq 0x5879a(%rip), %rsi # 0x86280
leaq 0x58799(%rip), %rdx # 0x86286
leaq -0x50(%rbp), %rcx
callq 0x5b020
callq 0x5b060
movq %rax, -0xb0(%rbp)
jmp 0x2db04
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movl $0x0, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5da90
movl %eax, -0xb4(%rbp)
jmp 0x2db2d
movl -0xb4(%rbp), %eax
movl %eax, -0x64(%rbp)
callq 0x5b070
movq %rax, -0xc8(%rbp)
jmp 0x2db44
movq -0xc8(%rbp), %rax
movq (%rax), %rsi
leaq -0x88(%rbp), %rdi
movl $0x3e, %edx
callq 0x5d7c0
jmp 0x2db61
movq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x64(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1aa10
jmp 0x2db7e
jmp 0x2dc03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xd0(%rbp)
jmp 0x2dba6
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
callq 0x5b070
movq %rax, -0xd8(%rbp)
jmp 0x2dbc5
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x3e, %edx
callq 0x5d7c0
jmp 0x2dbe2
movq -0xe0(%rbp), %rdi
leaq 0x34f6b(%rip), %rdx # 0x62b5b
leaq -0xa8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2dbfe
callq 0x153e0
jmp 0x2dc05
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x153e0
jmp 0x2dc21
jmp 0x2dc23
movq -0x58(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,070 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsWithALiteral::~TestCheckEqualsWithStringsWorksOnContentsWithALiteral() | TEST(CheckEqualsWithStringsWorksOnContentsWithALiteral)
{
char const* const p1 = txt1;
TestResults results;
CheckEqual(results, "Hello", p1, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2c7c0
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,071 | (anonymous namespace)::TestCheckEqualsWithStringsWorksOnContentsWithALiteral::RunImpl() const | TEST(CheckEqualsWithStringsWorksOnContentsWithALiteral)
{
char const* const p1 = txt1;
TestResults results;
CheckEqual(results, "Hello", p1, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x585fa(%rip), %rax # 0x86280
movq %rax, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
leaq -0x48(%rbp), %rdi
leaq 0x3c1b6(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
leaq -0x28(%rbp), %rdi
leaq 0x34e1d(%rip), %rsi # 0x62ad8
leaq 0x585be(%rip), %rdx # 0x86280
leaq -0x48(%rbp), %rcx
callq 0x5ae20
callq 0x5b060
movq %rax, -0xa8(%rbp)
jmp 0x2dcd9
movq -0xa8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
movl $0x0, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5da90
movl %eax, -0xac(%rbp)
jmp 0x2dd02
movl -0xac(%rbp), %eax
movl %eax, -0x5c(%rbp)
callq 0x5b070
movq %rax, -0xc0(%rbp)
jmp 0x2dd19
movq -0xc0(%rbp), %rax
movq (%rax), %rsi
leaq -0x80(%rbp), %rdi
movl $0x46, %edx
callq 0x5d7c0
jmp 0x2dd33
movq -0xb8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x5c(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x1aa10
jmp 0x2dd4d
jmp 0x2ddd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movq -0x50(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xc8(%rbp)
jmp 0x2dd75
movq -0xc8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
callq 0x5b070
movq %rax, -0xd0(%rbp)
jmp 0x2dd94
movq -0xd0(%rbp), %rax
movq (%rax), %rsi
leaq -0xa0(%rbp), %rdi
movl $0x46, %edx
callq 0x5d7c0
jmp 0x2ddb1
movq -0xd8(%rbp), %rdi
leaq 0x34d9c(%rip), %rdx # 0x62b5b
leaq -0xa0(%rbp), %rsi
callq 0x5d9a0
jmp 0x2ddcd
callq 0x153e0
jmp 0x2ddd4
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x153e0
jmp 0x2ddf0
jmp 0x2ddf2
movq -0x50(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,072 | (anonymous namespace)::TestCheckEqualFailureIncludesCheckExpectedAndActual::~TestCheckEqualFailureIncludesCheckExpectedAndActual() | TEST(CheckEqualFailureIncludesCheckExpectedAndActual)
{
RecordingReporter reporter;
TestResults results(&reporter);
const int something = 2;
CheckEqual(results, 1, something, TestDetails("", "", "", 0));
using namespace std;
CHECK(strstr(reporter.lastFailedMessage, "xpected 1"));
CHECK(strstr(reporter.lastFailedMessage, "was 2"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2c840
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,073 | (anonymous namespace)::TestCheckEqualFailureIncludesCheckExpectedAndActual::RunImpl() const | TEST(CheckEqualFailureIncludesCheckExpectedAndActual)
{
RecordingReporter reporter;
TestResults results(&reporter);
const int something = 2;
CheckEqual(results, 1, something, TestDetails("", "", "", 0));
using namespace std;
CHECK(strstr(reporter.lastFailedMessage, "xpected 1"));
CHECK(strstr(reporter.lastFailedMessage, "was 2"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x980, %rsp # imm = 0x980
movq %rdi, -0x8(%rbp)
leaq -0x838(%rbp), %rdi
movq %rdi, -0x910(%rbp)
callq 0x2a3f0
movq -0x910(%rbp), %rsi
leaq -0x850(%rbp), %rdi
callq 0x5d910
jmp 0x2de77
movl $0x2, -0x860(%rbp)
movl $0x1, -0x864(%rbp)
leaq 0x3bfc6(%rip), %rcx # 0x69e58
leaq -0x888(%rbp), %rdi
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
jmp 0x2dea9
leaq -0x850(%rbp), %rdi
leaq -0x864(%rbp), %rsi
leaq -0x860(%rbp), %rdx
leaq -0x888(%rbp), %rcx
callq 0x1aa10
jmp 0x2decc
jmp 0x2dece
leaq -0x324(%rbp), %rdi
leaq 0x34db8(%rip), %rsi # 0x62c94
callq 0x15050
movq %rax, %rdi
callq 0x2a7c0
movb %al, -0x911(%rbp)
jmp 0x2def1
movb -0x911(%rbp), %al
testb $0x1, %al
jne 0x2e0b4
jmp 0x2df01
callq 0x5b060
movq %rax, -0x920(%rbp)
jmp 0x2df0f
movq -0x920(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x930(%rbp)
callq 0x5b070
movq %rax, -0x928(%rbp)
jmp 0x2df2e
movq -0x928(%rbp), %rax
movq (%rax), %rsi
leaq -0x8a8(%rbp), %rdi
movl $0x51, %edx
callq 0x5d7c0
jmp 0x2df4b
movq -0x930(%rbp), %rdi
leaq 0x34d45(%rip), %rdx # 0x62c9e
leaq -0x8a8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2df67
jmp 0x2e0b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
jmp 0x2e19a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
movq -0x858(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x938(%rbp)
jmp 0x2dfaf
movq -0x938(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x948(%rbp)
callq 0x5b070
movq %rax, -0x940(%rbp)
jmp 0x2dfce
movq -0x940(%rbp), %rax
movq (%rax), %rsi
leaq -0x8c8(%rbp), %rdi
movl $0x51, %edx
callq 0x5d7c0
jmp 0x2dfeb
movq -0x948(%rbp), %rdi
leaq 0x34cd5(%rip), %rdx # 0x62cce
leaq -0x8c8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2e007
callq 0x153e0
jmp 0x2e00e
jmp 0x2e010
jmp 0x2e012
jmp 0x2e014
jmp 0x2e016
leaq -0x324(%rbp), %rdi
leaq 0x3b6d1(%rip), %rsi # 0x696f5
callq 0x15050
movq %rax, %rdi
callq 0x2a7c0
movb %al, -0x949(%rbp)
jmp 0x2e039
movb -0x949(%rbp), %al
testb $0x1, %al
jne 0x2e17d
jmp 0x2e049
callq 0x5b060
movq %rax, -0x958(%rbp)
jmp 0x2e057
movq -0x958(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x968(%rbp)
callq 0x5b070
movq %rax, -0x960(%rbp)
jmp 0x2e076
movq -0x960(%rbp), %rax
movq (%rax), %rsi
leaq -0x8e8(%rbp), %rdi
movl $0x52, %edx
callq 0x5d7c0
jmp 0x2e093
movq -0x968(%rbp), %rdi
leaq 0x34c7b(%rip), %rdx # 0x62d1c
leaq -0x8e8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2e0af
jmp 0x2e17d
jmp 0x2e010
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
callq 0x153e0
jmp 0x2e0d2
jmp 0x2e19a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
movq -0x858(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x970(%rbp)
jmp 0x2e103
movq -0x970(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x980(%rbp)
callq 0x5b070
movq %rax, -0x978(%rbp)
jmp 0x2e122
movq -0x978(%rbp), %rax
movq (%rax), %rsi
leaq -0x908(%rbp), %rdi
movl $0x52, %edx
callq 0x5d7c0
jmp 0x2e13f
movq -0x980(%rbp), %rdi
leaq 0x34bfb(%rip), %rdx # 0x62d48
leaq -0x908(%rbp), %rsi
callq 0x5d9a0
jmp 0x2e15b
callq 0x153e0
jmp 0x2e162
jmp 0x2e164
jmp 0x2e166
jmp 0x2e168
leaq -0x838(%rbp), %rdi
callq 0x2a5a0
addq $0x980, %rsp # imm = 0x980
popq %rbp
retq
jmp 0x2e164
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
callq 0x153e0
jmp 0x2e198
jmp 0x2e19a
leaq -0x838(%rbp), %rdi
callq 0x2a5a0
movq -0x858(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,074 | (anonymous namespace)::TestCheckEqualFailureIncludesDetails::~TestCheckEqualFailureIncludesDetails() | TEST(CheckEqualFailureIncludesDetails)
{
RecordingReporter reporter;
TestResults results(&reporter);
TestDetails const details("mytest", "mysuite", "file.h", 101);
CheckEqual(results, 1, 2, details);
CHECK_EQUAL("mytest", reporter.lastFailedTest);
CHECK_EQUAL("mysuite", reporter.lastFailedSuite);
CHECK_EQUAL("file.h", reporter.lastFailedFile);
CHECK_EQUAL(101, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2c8c0
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,075 | (anonymous namespace)::TestCheckEqualFailureIncludesDetails::RunImpl() const | TEST(CheckEqualFailureIncludesDetails)
{
RecordingReporter reporter;
TestResults results(&reporter);
TestDetails const details("mytest", "mysuite", "file.h", 101);
CheckEqual(results, 1, 2, details);
CHECK_EQUAL("mytest", reporter.lastFailedTest);
CHECK_EQUAL("mysuite", reporter.lastFailedSuite);
CHECK_EQUAL("file.h", reporter.lastFailedFile);
CHECK_EQUAL(101, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0xa80, %rsp # imm = 0xA80
movq %rdi, -0x8(%rbp)
leaq -0x838(%rbp), %rdi
movq %rdi, -0x998(%rbp)
callq 0x2a3f0
movq -0x998(%rbp), %rsi
leaq -0x850(%rbp), %rdi
callq 0x5d910
jmp 0x2e227
leaq 0x34b85(%rip), %rsi # 0x62db3
leaq 0x34b85(%rip), %rdx # 0x62dba
leaq 0x34b86(%rip), %rcx # 0x62dc2
leaq -0x880(%rbp), %rdi
movl $0x65, %r8d
callq 0x5d780
jmp 0x2e250
movl $0x1, -0x884(%rbp)
movl $0x2, -0x888(%rbp)
leaq -0x850(%rbp), %rdi
leaq -0x884(%rbp), %rsi
leaq -0x888(%rbp), %rdx
leaq -0x880(%rbp), %rcx
callq 0x1aa10
jmp 0x2e287
jmp 0x2e289
callq 0x5b060
movq %rax, -0x9a0(%rbp)
jmp 0x2e297
movq -0x9a0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x9b8(%rbp)
leaq -0x424(%rbp), %rax
movq %rax, -0x9b0(%rbp)
callq 0x5b070
movq %rax, -0x9a8(%rbp)
jmp 0x2e2c4
movq -0x9a8(%rbp), %rax
movq (%rax), %rsi
leaq -0x8a8(%rbp), %rdi
movl $0x5d, %edx
callq 0x5d7c0
jmp 0x2e2e1
movq -0x9b0(%rbp), %rdx
movq -0x9b8(%rbp), %rdi
leaq 0x34abd(%rip), %rsi # 0x62db3
leaq -0x8a8(%rbp), %rcx
callq 0x5b020
jmp 0x2e304
jmp 0x2e3ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
jmp 0x2e77e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
movq -0x858(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x9c0(%rbp)
jmp 0x2e34c
movq -0x9c0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x9d0(%rbp)
callq 0x5b070
movq %rax, -0x9c8(%rbp)
jmp 0x2e36b
movq -0x9c8(%rbp), %rax
movq (%rax), %rsi
leaq -0x8c8(%rbp), %rdi
movl $0x5d, %edx
callq 0x5d7c0
jmp 0x2e388
movq -0x9d0(%rbp), %rdi
leaq 0x34a33(%rip), %rdx # 0x62dc9
leaq -0x8c8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2e3a4
callq 0x153e0
jmp 0x2e3ab
jmp 0x2e3ad
jmp 0x2e3af
jmp 0x2e3b1
jmp 0x2e3b3
callq 0x5b060
movq %rax, -0x9d8(%rbp)
jmp 0x2e3c1
movq -0x9d8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x9f0(%rbp)
leaq -0x524(%rbp), %rax
movq %rax, -0x9e8(%rbp)
callq 0x5b070
movq %rax, -0x9e0(%rbp)
jmp 0x2e3ee
movq -0x9e0(%rbp), %rax
movq (%rax), %rsi
leaq -0x8e8(%rbp), %rdi
movl $0x5e, %edx
callq 0x5d7c0
jmp 0x2e40b
movq -0x9e8(%rbp), %rdx
movq -0x9f0(%rbp), %rdi
leaq 0x3499a(%rip), %rsi # 0x62dba
leaq -0x8e8(%rbp), %rcx
callq 0x5b020
jmp 0x2e42e
jmp 0x2e4de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
callq 0x153e0
jmp 0x2e44c
jmp 0x2e77e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
movq -0x858(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x9f8(%rbp)
jmp 0x2e47d
movq -0x9f8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa08(%rbp)
callq 0x5b070
movq %rax, -0xa00(%rbp)
jmp 0x2e49c
movq -0xa00(%rbp), %rax
movq (%rax), %rsi
leaq -0x908(%rbp), %rdi
movl $0x5e, %edx
callq 0x5d7c0
jmp 0x2e4b9
movq -0xa08(%rbp), %rdi
leaq 0x34948(%rip), %rdx # 0x62e0f
leaq -0x908(%rbp), %rsi
callq 0x5d9a0
jmp 0x2e4d5
callq 0x153e0
jmp 0x2e4dc
jmp 0x2e4de
jmp 0x2e4e0
jmp 0x2e4e2
jmp 0x2e4e4
callq 0x5b060
movq %rax, -0xa10(%rbp)
jmp 0x2e4f2
movq -0xa10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa28(%rbp)
leaq -0x628(%rbp), %rax
movq %rax, -0xa20(%rbp)
callq 0x5b070
movq %rax, -0xa18(%rbp)
jmp 0x2e51f
movq -0xa18(%rbp), %rax
movq (%rax), %rsi
leaq -0x928(%rbp), %rdi
movl $0x5f, %edx
callq 0x5d7c0
jmp 0x2e53c
movq -0xa20(%rbp), %rdx
movq -0xa28(%rbp), %rdi
leaq 0x34871(%rip), %rsi # 0x62dc2
leaq -0x928(%rbp), %rcx
callq 0x5b020
jmp 0x2e55f
jmp 0x2e60f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
callq 0x153e0
jmp 0x2e57d
jmp 0x2e77e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
movq -0x858(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xa30(%rbp)
jmp 0x2e5ae
movq -0xa30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa40(%rbp)
callq 0x5b070
movq %rax, -0xa38(%rbp)
jmp 0x2e5cd
movq -0xa38(%rbp), %rax
movq (%rax), %rsi
leaq -0x948(%rbp), %rdi
movl $0x5f, %edx
callq 0x5d7c0
jmp 0x2e5ea
movq -0xa40(%rbp), %rdi
leaq 0x3485f(%rip), %rdx # 0x62e57
leaq -0x948(%rbp), %rsi
callq 0x5d9a0
jmp 0x2e606
callq 0x153e0
jmp 0x2e60d
jmp 0x2e60f
jmp 0x2e611
jmp 0x2e613
jmp 0x2e615
callq 0x5b060
movq %rax, -0xa48(%rbp)
jmp 0x2e623
movq -0xa48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa60(%rbp)
movl $0x65, -0x94c(%rbp)
leaq -0x528(%rbp), %rax
movq %rax, -0xa58(%rbp)
callq 0x5b070
movq %rax, -0xa50(%rbp)
jmp 0x2e65a
movq -0xa50(%rbp), %rax
movq (%rax), %rsi
leaq -0x970(%rbp), %rdi
movl $0x60, %edx
callq 0x5d7c0
jmp 0x2e677
movq -0xa58(%rbp), %rdx
movq -0xa60(%rbp), %rdi
leaq -0x94c(%rbp), %rsi
leaq -0x970(%rbp), %rcx
callq 0x1aa10
jmp 0x2e69a
jmp 0x2e74a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
callq 0x153e0
jmp 0x2e6b8
jmp 0x2e77e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
movq -0x858(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xa68(%rbp)
jmp 0x2e6e9
movq -0xa68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa78(%rbp)
callq 0x5b070
movq %rax, -0xa70(%rbp)
jmp 0x2e708
movq -0xa70(%rbp), %rax
movq (%rax), %rsi
leaq -0x990(%rbp), %rdi
movl $0x60, %edx
callq 0x5d7c0
jmp 0x2e725
movq -0xa78(%rbp), %rdi
leaq 0x3476a(%rip), %rdx # 0x62e9d
leaq -0x990(%rbp), %rsi
callq 0x5d9a0
jmp 0x2e741
callq 0x153e0
jmp 0x2e748
jmp 0x2e74a
jmp 0x2e74c
jmp 0x2e74e
leaq -0x838(%rbp), %rdi
callq 0x2a5a0
addq $0xa80, %rsp # imm = 0xA80
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
callq 0x153e0
jmp 0x2e77c
jmp 0x2e77e
leaq -0x838(%rbp), %rdi
callq 0x2a5a0
movq -0x858(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,076 | (anonymous namespace)::TestCheckCloseTrue::~TestCheckCloseTrue() | TEST(CheckCloseTrue)
{
TestResults results;
CheckClose(results, 3.001f, 3.0f, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2c940
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,077 | (anonymous namespace)::TestCheckCloseTrue::RunImpl() const | TEST(CheckCloseTrue)
{
TestResults results;
CheckClose(results, 3.001f, 3.0f, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
movss 0x341e4(%rip), %xmm0 # 0x629d8
movss %xmm0, -0x24(%rbp)
movss 0x341d3(%rip), %xmm0 # 0x629d4
movss %xmm0, -0x28(%rbp)
movss 0x341c2(%rip), %xmm0 # 0x629d0
movss %xmm0, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x3b63a(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x50(%rbp), %r8
callq 0x2a7e0
callq 0x5b060
movq %rax, -0xb0(%rbp)
jmp 0x2e853
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movl $0x0, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5da90
movl %eax, -0xb4(%rbp)
jmp 0x2e87c
movl -0xb4(%rbp), %eax
movl %eax, -0x64(%rbp)
callq 0x5b070
movq %rax, -0xc8(%rbp)
jmp 0x2e893
movq -0xc8(%rbp), %rax
movq (%rax), %rsi
leaq -0x88(%rbp), %rdi
movl $0x67, %edx
callq 0x5d7c0
jmp 0x2e8b0
movq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x64(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1aa10
jmp 0x2e8cd
jmp 0x2e952
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xd0(%rbp)
jmp 0x2e8f5
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
callq 0x5b070
movq %rax, -0xd8(%rbp)
jmp 0x2e914
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x67, %edx
callq 0x5d7c0
jmp 0x2e931
movq -0xe0(%rbp), %rdi
leaq 0x3421c(%rip), %rdx # 0x62b5b
leaq -0xa8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2e94d
callq 0x153e0
jmp 0x2e954
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x153e0
jmp 0x2e970
jmp 0x2e972
movq -0x58(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,078 | (anonymous namespace)::TestCheckCloseFalse::~TestCheckCloseFalse() | TEST(CheckCloseFalse)
{
TestResults results;
CheckClose(results, 3.12f, 3.0f, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2c9c0
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,079 | (anonymous namespace)::TestCheckCloseFalse::RunImpl() const | TEST(CheckCloseFalse)
{
TestResults results;
CheckClose(results, 3.12f, 3.0f, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
movss 0x33ff8(%rip), %xmm0 # 0x629dc
movss %xmm0, -0x24(%rbp)
movss 0x33fe3(%rip), %xmm0 # 0x629d4
movss %xmm0, -0x28(%rbp)
movss 0x33fd2(%rip), %xmm0 # 0x629d0
movss %xmm0, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x3b44a(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x50(%rbp), %r8
callq 0x2a7e0
callq 0x5b060
movq %rax, -0xb0(%rbp)
jmp 0x2ea43
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movl $0x1, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5da90
movl %eax, -0xb4(%rbp)
jmp 0x2ea6c
movl -0xb4(%rbp), %eax
movl %eax, -0x64(%rbp)
callq 0x5b070
movq %rax, -0xc8(%rbp)
jmp 0x2ea83
movq -0xc8(%rbp), %rax
movq (%rax), %rsi
leaq -0x88(%rbp), %rdi
movl $0x6e, %edx
callq 0x5d7c0
jmp 0x2eaa0
movq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x64(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1aa10
jmp 0x2eabd
jmp 0x2eb42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xd0(%rbp)
jmp 0x2eae5
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
callq 0x5b070
movq %rax, -0xd8(%rbp)
jmp 0x2eb04
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x6e, %edx
callq 0x5d7c0
jmp 0x2eb21
movq -0xe0(%rbp), %rdi
leaq 0x33fb5(%rip), %rdx # 0x62ae4
leaq -0xa8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2eb3d
callq 0x153e0
jmp 0x2eb44
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x153e0
jmp 0x2eb60
jmp 0x2eb62
movq -0x58(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,080 | (anonymous namespace)::TestCheckCloseWithZeroEpsilonWorksForSameNumber::~TestCheckCloseWithZeroEpsilonWorksForSameNumber() | TEST(CheckCloseWithZeroEpsilonWorksForSameNumber)
{
TestResults results;
CheckClose(results, 0.1f, 0.1f, 0, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2ca40
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,081 | (anonymous namespace)::TestCheckCloseWithZeroEpsilonWorksForSameNumber::RunImpl() const | TEST(CheckCloseWithZeroEpsilonWorksForSameNumber)
{
TestResults results;
CheckClose(results, 0.1f, 0.1f, 0, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
movss 0x33dfc(%rip), %xmm0 # 0x629d0
movss %xmm0, -0x24(%rbp)
movss 0x33def(%rip), %xmm0 # 0x629d0
movss %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x3b260(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x50(%rbp), %r8
callq 0x31840
callq 0x5b060
movq %rax, -0xb0(%rbp)
jmp 0x2ec2d
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movl $0x0, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5da90
movl %eax, -0xb4(%rbp)
jmp 0x2ec56
movl -0xb4(%rbp), %eax
movl %eax, -0x64(%rbp)
callq 0x5b070
movq %rax, -0xc8(%rbp)
jmp 0x2ec6d
movq -0xc8(%rbp), %rax
movq (%rax), %rsi
leaq -0x88(%rbp), %rdi
movl $0x75, %edx
callq 0x5d7c0
jmp 0x2ec8a
movq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x64(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1aa10
jmp 0x2eca7
jmp 0x2ed2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xd0(%rbp)
jmp 0x2eccf
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
callq 0x5b070
movq %rax, -0xd8(%rbp)
jmp 0x2ecee
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x75, %edx
callq 0x5d7c0
jmp 0x2ed0b
movq -0xe0(%rbp), %rdi
leaq 0x33e42(%rip), %rdx # 0x62b5b
leaq -0xa8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2ed27
callq 0x153e0
jmp 0x2ed2e
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x153e0
jmp 0x2ed4a
jmp 0x2ed4c
movq -0x58(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,082 | (anonymous namespace)::TestCheckCloseWithNaNFails::~TestCheckCloseWithNaNFails() | TEST(CheckCloseWithNaNFails)
{
union
{
unsigned int bitpattern;
float nan;
};
bitpattern = 0xFFFFFFFF;
TestResults results;
CheckClose(results, 3.0f, nan, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2cac0
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,083 | (anonymous namespace)::TestCheckCloseWithNaNFails::RunImpl() const | TEST(CheckCloseWithNaNFails)
{
union
{
unsigned int bitpattern;
float nan;
};
bitpattern = 0xFFFFFFFF;
TestResults results;
CheckClose(results, 3.0f, nan, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
movss 0x33c19(%rip), %xmm0 # 0x629d4
movss %xmm0, -0x2c(%rbp)
movss 0x33c08(%rip), %xmm0 # 0x629d0
movss %xmm0, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x3b080(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0xc(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x50(%rbp), %r8
callq 0x2a7e0
callq 0x5b060
movq %rax, -0xb0(%rbp)
jmp 0x2ee0d
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movl $0x1, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5da90
movl %eax, -0xb4(%rbp)
jmp 0x2ee36
movl -0xb4(%rbp), %eax
movl %eax, -0x64(%rbp)
callq 0x5b070
movq %rax, -0xc8(%rbp)
jmp 0x2ee4d
movq -0xc8(%rbp), %rax
movq (%rax), %rsi
leaq -0x88(%rbp), %rdi
movl $0x82, %edx
callq 0x5d7c0
jmp 0x2ee6a
movq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x64(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1aa10
jmp 0x2ee87
jmp 0x2ef0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xd0(%rbp)
jmp 0x2eeaf
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
callq 0x5b070
movq %rax, -0xd8(%rbp)
jmp 0x2eece
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x82, %edx
callq 0x5d7c0
jmp 0x2eeeb
movq -0xe0(%rbp), %rdi
leaq 0x33beb(%rip), %rdx # 0x62ae4
leaq -0xa8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2ef07
callq 0x153e0
jmp 0x2ef0e
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x153e0
jmp 0x2ef2a
jmp 0x2ef2c
movq -0x58(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,084 | (anonymous namespace)::TestCheckCloseWithNaNAgainstItselfFails::~TestCheckCloseWithNaNAgainstItselfFails() | TEST(CheckCloseWithNaNAgainstItselfFails)
{
union
{
unsigned int bitpattern;
float nan;
};
bitpattern = 0xFFFFFFFF;
TestResults results;
CheckClose(results, nan, nan, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2cb40
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,085 | (anonymous namespace)::TestCheckCloseWithNaNAgainstItselfFails::RunImpl() const | TEST(CheckCloseWithNaNAgainstItselfFails)
{
union
{
unsigned int bitpattern;
float nan;
};
bitpattern = 0xFFFFFFFF;
TestResults results;
CheckClose(results, nan, nan, 0.1f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
movss 0x33a35(%rip), %xmm0 # 0x629d0
movss %xmm0, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x3aead(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
leaq -0x28(%rbp), %rdi
leaq -0xc(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x50(%rbp), %r8
movq %rdx, %rsi
callq 0x2a7e0
callq 0x5b060
movq %rax, -0xb0(%rbp)
jmp 0x2efdf
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movl $0x1, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5da90
movl %eax, -0xb4(%rbp)
jmp 0x2f008
movl -0xb4(%rbp), %eax
movl %eax, -0x64(%rbp)
callq 0x5b070
movq %rax, -0xc8(%rbp)
jmp 0x2f01f
movq -0xc8(%rbp), %rax
movq (%rax), %rsi
leaq -0x88(%rbp), %rdi
movl $0x8f, %edx
callq 0x5d7c0
jmp 0x2f03c
movq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x64(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1aa10
jmp 0x2f059
jmp 0x2f0de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xd0(%rbp)
jmp 0x2f081
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
callq 0x5b070
movq %rax, -0xd8(%rbp)
jmp 0x2f0a0
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x8f, %edx
callq 0x5d7c0
jmp 0x2f0bd
movq -0xe0(%rbp), %rdi
leaq 0x33a19(%rip), %rdx # 0x62ae4
leaq -0xa8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2f0d9
callq 0x153e0
jmp 0x2f0e0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x153e0
jmp 0x2f0fc
jmp 0x2f0fe
movq -0x58(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,086 | (anonymous namespace)::TestCheckCloseFailureIncludesCheckExpectedAndActual::~TestCheckCloseFailureIncludesCheckExpectedAndActual() | TEST(CheckCloseFailureIncludesCheckExpectedAndActual)
{
RecordingReporter reporter;
TestResults results(&reporter);
const float expected = 0.9f;
const float actual = 1.1f;
CheckClose(results, expected, actual, 0.01f, TestDetails("", "", "", 0));
using namespace std;
CHECK(strstr(reporter.lastFailedMessage, "xpected 0.9"));
CHECK(strstr(reporter.lastFailedMessage, "was 1.1"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2cbc0
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,087 | (anonymous namespace)::TestCheckCloseFailureIncludesCheckExpectedAndActual::RunImpl() const | TEST(CheckCloseFailureIncludesCheckExpectedAndActual)
{
RecordingReporter reporter;
TestResults results(&reporter);
const float expected = 0.9f;
const float actual = 1.1f;
CheckClose(results, expected, actual, 0.01f, TestDetails("", "", "", 0));
using namespace std;
CHECK(strstr(reporter.lastFailedMessage, "xpected 0.9"));
CHECK(strstr(reporter.lastFailedMessage, "was 1.1"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x970, %rsp # imm = 0x970
movq %rdi, -0x8(%rbp)
leaq -0x838(%rbp), %rdi
movq %rdi, -0x910(%rbp)
callq 0x2a3f0
movq -0x910(%rbp), %rsi
leaq -0x850(%rbp), %rdi
callq 0x5d910
jmp 0x2f177
movl $0x3f666666, -0x860(%rbp) # imm = 0x3F666666
movl $0x3f8ccccd, -0x864(%rbp) # imm = 0x3F8CCCCD
movl $0x3c23d70a, -0x868(%rbp) # imm = 0x3C23D70A
leaq 0x3acbc(%rip), %rcx # 0x69e58
leaq -0x888(%rbp), %rdi
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
jmp 0x2f1b3
leaq -0x850(%rbp), %rdi
leaq -0x860(%rbp), %rsi
leaq -0x864(%rbp), %rdx
leaq -0x868(%rbp), %rcx
leaq -0x888(%rbp), %r8
callq 0x2a7e0
jmp 0x2f1dd
jmp 0x2f1df
leaq -0x838(%rbp), %rdi
addq $0x514, %rdi # imm = 0x514
leaq 0x33da0(%rip), %rsi # 0x62f94
callq 0x15050
movq %rax, %rdi
callq 0x2a7c0
testb $0x1, %al
jne 0x2f3b3
callq 0x5b060
movq %rax, -0x918(%rbp)
jmp 0x2f217
movq -0x918(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x928(%rbp)
callq 0x5b070
movq %rax, -0x920(%rbp)
jmp 0x2f236
movq -0x920(%rbp), %rax
movq (%rax), %rsi
leaq -0x8a8(%rbp), %rdi
movl $0x9b, %edx
callq 0x5d7c0
jmp 0x2f253
movq -0x928(%rbp), %rdi
leaq 0x33d3f(%rip), %rdx # 0x62fa0
leaq -0x8a8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2f26f
jmp 0x2f3b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
jmp 0x2f499
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
movq -0x858(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x930(%rbp)
jmp 0x2f2b7
movq -0x930(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x940(%rbp)
callq 0x5b070
movq %rax, -0x938(%rbp)
jmp 0x2f2d6
movq -0x938(%rbp), %rax
movq (%rax), %rsi
leaq -0x8c8(%rbp), %rdi
movl $0x9b, %edx
callq 0x5d7c0
jmp 0x2f2f3
movq -0x940(%rbp), %rdi
leaq 0x33cd1(%rip), %rdx # 0x62fd2
leaq -0x8c8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2f30f
callq 0x153e0
jmp 0x2f316
jmp 0x2f318
jmp 0x2f31a
jmp 0x2f31c
jmp 0x2f31e
leaq -0x838(%rbp), %rdi
addq $0x514, %rdi # imm = 0x514
leaq 0x33cef(%rip), %rsi # 0x63022
callq 0x15050
movq %rax, %rdi
callq 0x2a7c0
testb $0x1, %al
jne 0x2f47c
callq 0x5b060
movq %rax, -0x948(%rbp)
jmp 0x2f356
movq -0x948(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x958(%rbp)
callq 0x5b070
movq %rax, -0x950(%rbp)
jmp 0x2f375
movq -0x950(%rbp), %rax
movq (%rax), %rsi
leaq -0x8e8(%rbp), %rdi
movl $0x9c, %edx
callq 0x5d7c0
jmp 0x2f392
movq -0x958(%rbp), %rdi
leaq 0x33c8a(%rip), %rdx # 0x6302a
leaq -0x8e8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2f3ae
jmp 0x2f47c
jmp 0x2f318
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
callq 0x153e0
jmp 0x2f3d1
jmp 0x2f499
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
movq -0x858(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x960(%rbp)
jmp 0x2f402
movq -0x960(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x970(%rbp)
callq 0x5b070
movq %rax, -0x968(%rbp)
jmp 0x2f421
movq -0x968(%rbp), %rax
movq (%rax), %rsi
leaq -0x908(%rbp), %rdi
movl $0x9c, %edx
callq 0x5d7c0
jmp 0x2f43e
movq -0x970(%rbp), %rdi
leaq 0x33c0c(%rip), %rdx # 0x63058
leaq -0x908(%rbp), %rsi
callq 0x5d9a0
jmp 0x2f45a
callq 0x153e0
jmp 0x2f461
jmp 0x2f463
jmp 0x2f465
jmp 0x2f467
leaq -0x838(%rbp), %rdi
callq 0x2a5a0
addq $0x970, %rsp # imm = 0x970
popq %rbp
retq
jmp 0x2f463
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
callq 0x153e0
jmp 0x2f497
jmp 0x2f499
leaq -0x838(%rbp), %rdi
callq 0x2a5a0
movq -0x858(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,088 | (anonymous namespace)::TestCheckCloseFailureIncludesTolerance::~TestCheckCloseFailureIncludesTolerance() | TEST(CheckCloseFailureIncludesTolerance)
{
RecordingReporter reporter;
TestResults results(&reporter);
CheckClose(results, 2, 3, 0.01f, TestDetails("", "", "", 0));
using namespace std;
CHECK(strstr(reporter.lastFailedMessage, "0.01"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2cc40
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,089 | (anonymous namespace)::TestCheckCloseFailureIncludesTolerance::RunImpl() const | TEST(CheckCloseFailureIncludesTolerance)
{
RecordingReporter reporter;
TestResults results(&reporter);
CheckClose(results, 2, 3, 0.01f, TestDetails("", "", "", 0));
using namespace std;
CHECK(strstr(reporter.lastFailedMessage, "0.01"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x900, %rsp # imm = 0x900
movq %rdi, -0x8(%rbp)
leaq -0x838(%rbp), %rdi
movq %rdi, -0x8d0(%rbp)
callq 0x2a3f0
movq -0x8d0(%rbp), %rsi
leaq -0x850(%rbp), %rdi
callq 0x5d910
jmp 0x2f527
movl $0x2, -0x860(%rbp)
movl $0x3, -0x864(%rbp)
movl $0x3c23d70a, -0x868(%rbp) # imm = 0x3C23D70A
leaq 0x3a90c(%rip), %rcx # 0x69e58
leaq -0x888(%rbp), %rdi
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
jmp 0x2f563
leaq -0x850(%rbp), %rdi
leaq -0x860(%rbp), %rsi
leaq -0x864(%rbp), %rdx
leaq -0x868(%rbp), %rcx
leaq -0x888(%rbp), %r8
callq 0x2a9c0
jmp 0x2f58d
jmp 0x2f58f
leaq -0x838(%rbp), %rdi
addq $0x514, %rdi # imm = 0x514
leaq 0x31e42(%rip), %rsi # 0x613e6
callq 0x15050
movq %rax, %rdi
callq 0x2a7c0
testb $0x1, %al
jne 0x2f6e1
callq 0x5b060
movq %rax, -0x8d8(%rbp)
jmp 0x2f5c7
movq -0x8d8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8e8(%rbp)
callq 0x5b070
movq %rax, -0x8e0(%rbp)
jmp 0x2f5e6
movq -0x8e0(%rbp), %rax
movq (%rax), %rsi
leaq -0x8a8(%rbp), %rdi
movl $0xa6, %edx
callq 0x5d7c0
jmp 0x2f603
movq -0x8e8(%rbp), %rdi
leaq 0x31dda(%rip), %rdx # 0x613eb
leaq -0x8a8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2f61f
jmp 0x2f6e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
jmp 0x2f6fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
movq -0x858(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x8f0(%rbp)
jmp 0x2f667
movq -0x8f0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x900(%rbp)
callq 0x5b070
movq %rax, -0x8f8(%rbp)
jmp 0x2f686
movq -0x8f8(%rbp), %rax
movq (%rax), %rsi
leaq -0x8c8(%rbp), %rdi
movl $0xa6, %edx
callq 0x5d7c0
jmp 0x2f6a3
movq -0x900(%rbp), %rdi
leaq 0x31d65(%rip), %rdx # 0x61416
leaq -0x8c8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2f6bf
callq 0x153e0
jmp 0x2f6c6
jmp 0x2f6c8
jmp 0x2f6ca
jmp 0x2f6cc
leaq -0x838(%rbp), %rdi
callq 0x2a5a0
addq $0x900, %rsp # imm = 0x900
popq %rbp
retq
jmp 0x2f6c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
callq 0x153e0
jmp 0x2f6fc
jmp 0x2f6fe
leaq -0x838(%rbp), %rdi
callq 0x2a5a0
movq -0x858(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,090 | (anonymous namespace)::TestCheckCloseFailureIncludesDetails::~TestCheckCloseFailureIncludesDetails() | TEST(CheckCloseFailureIncludesDetails)
{
RecordingReporter reporter;
TestResults results(&reporter);
TestDetails const details("mytest", "mysuite", "header.h", 10);
CheckClose(results, 2, 3, 0.01f, details);
CHECK_EQUAL("mytest", reporter.lastFailedTest);
CHECK_EQUAL("mysuite", reporter.lastFailedSuite);
CHECK_EQUAL("header.h", reporter.lastFailedFile);
CHECK_EQUAL(10, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2ccc0
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,091 | (anonymous namespace)::TestCheckCloseFailureIncludesDetails::RunImpl() const | TEST(CheckCloseFailureIncludesDetails)
{
RecordingReporter reporter;
TestResults results(&reporter);
TestDetails const details("mytest", "mysuite", "header.h", 10);
CheckClose(results, 2, 3, 0.01f, details);
CHECK_EQUAL("mytest", reporter.lastFailedTest);
CHECK_EQUAL("mysuite", reporter.lastFailedSuite);
CHECK_EQUAL("header.h", reporter.lastFailedFile);
CHECK_EQUAL(10, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0xa80, %rsp # imm = 0xA80
movq %rdi, -0x8(%rbp)
leaq -0x838(%rbp), %rdi
movq %rdi, -0x9a0(%rbp)
callq 0x2a3f0
movq -0x9a0(%rbp), %rsi
leaq -0x850(%rbp), %rdi
callq 0x5d910
jmp 0x2f787
leaq 0x33625(%rip), %rsi # 0x62db3
leaq 0x33625(%rip), %rdx # 0x62dba
leaq 0x3394c(%rip), %rcx # 0x630e8
leaq -0x880(%rbp), %rdi
movl $0xa, %r8d
callq 0x5d780
jmp 0x2f7b0
movl $0x2, -0x884(%rbp)
movl $0x3, -0x888(%rbp)
movl $0x3c23d70a, -0x88c(%rbp) # imm = 0x3C23D70A
leaq -0x850(%rbp), %rdi
leaq -0x884(%rbp), %rsi
leaq -0x888(%rbp), %rdx
leaq -0x88c(%rbp), %rcx
leaq -0x880(%rbp), %r8
callq 0x2a9c0
jmp 0x2f7f8
jmp 0x2f7fa
callq 0x5b060
movq %rax, -0x9a8(%rbp)
jmp 0x2f808
movq -0x9a8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x9c0(%rbp)
leaq -0x424(%rbp), %rax
movq %rax, -0x9b8(%rbp)
callq 0x5b070
movq %rax, -0x9b0(%rbp)
jmp 0x2f835
movq -0x9b0(%rbp), %rax
movq (%rax), %rsi
leaq -0x8b0(%rbp), %rdi
movl $0xb1, %edx
callq 0x5d7c0
jmp 0x2f852
movq -0x9b8(%rbp), %rdx
movq -0x9c0(%rbp), %rdi
leaq 0x3354c(%rip), %rsi # 0x62db3
leaq -0x8b0(%rbp), %rcx
callq 0x5b020
jmp 0x2f875
jmp 0x2f91e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
jmp 0x2fcef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
movq -0x858(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x9c8(%rbp)
jmp 0x2f8bd
movq -0x9c8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x9d8(%rbp)
callq 0x5b070
movq %rax, -0x9d0(%rbp)
jmp 0x2f8dc
movq -0x9d0(%rbp), %rax
movq (%rax), %rsi
leaq -0x8d0(%rbp), %rdi
movl $0xb1, %edx
callq 0x5d7c0
jmp 0x2f8f9
movq -0x9d8(%rbp), %rdi
leaq 0x334c2(%rip), %rdx # 0x62dc9
leaq -0x8d0(%rbp), %rsi
callq 0x5d9a0
jmp 0x2f915
callq 0x153e0
jmp 0x2f91c
jmp 0x2f91e
jmp 0x2f920
jmp 0x2f922
jmp 0x2f924
callq 0x5b060
movq %rax, -0x9e0(%rbp)
jmp 0x2f932
movq -0x9e0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x9f8(%rbp)
leaq -0x524(%rbp), %rax
movq %rax, -0x9f0(%rbp)
callq 0x5b070
movq %rax, -0x9e8(%rbp)
jmp 0x2f95f
movq -0x9e8(%rbp), %rax
movq (%rax), %rsi
leaq -0x8f0(%rbp), %rdi
movl $0xb2, %edx
callq 0x5d7c0
jmp 0x2f97c
movq -0x9f0(%rbp), %rdx
movq -0x9f8(%rbp), %rdi
leaq 0x33429(%rip), %rsi # 0x62dba
leaq -0x8f0(%rbp), %rcx
callq 0x5b020
jmp 0x2f99f
jmp 0x2fa4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
callq 0x153e0
jmp 0x2f9bd
jmp 0x2fcef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
movq -0x858(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xa00(%rbp)
jmp 0x2f9ee
movq -0xa00(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa10(%rbp)
callq 0x5b070
movq %rax, -0xa08(%rbp)
jmp 0x2fa0d
movq -0xa08(%rbp), %rax
movq (%rax), %rsi
leaq -0x910(%rbp), %rdi
movl $0xb2, %edx
callq 0x5d7c0
jmp 0x2fa2a
movq -0xa10(%rbp), %rdi
leaq 0x333d7(%rip), %rdx # 0x62e0f
leaq -0x910(%rbp), %rsi
callq 0x5d9a0
jmp 0x2fa46
callq 0x153e0
jmp 0x2fa4d
jmp 0x2fa4f
jmp 0x2fa51
jmp 0x2fa53
jmp 0x2fa55
callq 0x5b060
movq %rax, -0xa18(%rbp)
jmp 0x2fa63
movq -0xa18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa30(%rbp)
leaq -0x628(%rbp), %rax
movq %rax, -0xa28(%rbp)
callq 0x5b070
movq %rax, -0xa20(%rbp)
jmp 0x2fa90
movq -0xa20(%rbp), %rax
movq (%rax), %rsi
leaq -0x930(%rbp), %rdi
movl $0xb3, %edx
callq 0x5d7c0
jmp 0x2faad
movq -0xa28(%rbp), %rdx
movq -0xa30(%rbp), %rdi
leaq 0x33626(%rip), %rsi # 0x630e8
leaq -0x930(%rbp), %rcx
callq 0x5b020
jmp 0x2fad0
jmp 0x2fb80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
callq 0x153e0
jmp 0x2faee
jmp 0x2fcef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
movq -0x858(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xa38(%rbp)
jmp 0x2fb1f
movq -0xa38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa48(%rbp)
callq 0x5b070
movq %rax, -0xa40(%rbp)
jmp 0x2fb3e
movq -0xa40(%rbp), %rax
movq (%rax), %rsi
leaq -0x950(%rbp), %rdi
movl $0xb3, %edx
callq 0x5d7c0
jmp 0x2fb5b
movq -0xa48(%rbp), %rdi
leaq 0x33588(%rip), %rdx # 0x630f1
leaq -0x950(%rbp), %rsi
callq 0x5d9a0
jmp 0x2fb77
callq 0x153e0
jmp 0x2fb7e
jmp 0x2fb80
jmp 0x2fb82
jmp 0x2fb84
jmp 0x2fb86
callq 0x5b060
movq %rax, -0xa50(%rbp)
jmp 0x2fb94
movq -0xa50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa68(%rbp)
movl $0xa, -0x954(%rbp)
leaq -0x528(%rbp), %rax
movq %rax, -0xa60(%rbp)
callq 0x5b070
movq %rax, -0xa58(%rbp)
jmp 0x2fbcb
movq -0xa58(%rbp), %rax
movq (%rax), %rsi
leaq -0x978(%rbp), %rdi
movl $0xb4, %edx
callq 0x5d7c0
jmp 0x2fbe8
movq -0xa60(%rbp), %rdx
movq -0xa68(%rbp), %rdi
leaq -0x954(%rbp), %rsi
leaq -0x978(%rbp), %rcx
callq 0x1aa10
jmp 0x2fc0b
jmp 0x2fcbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
callq 0x153e0
jmp 0x2fc29
jmp 0x2fcef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
movq -0x858(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xa70(%rbp)
jmp 0x2fc5a
movq -0xa70(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa80(%rbp)
callq 0x5b070
movq %rax, -0xa78(%rbp)
jmp 0x2fc79
movq -0xa78(%rbp), %rax
movq (%rax), %rsi
leaq -0x998(%rbp), %rdi
movl $0xb4, %edx
callq 0x5d7c0
jmp 0x2fc96
movq -0xa80(%rbp), %rdi
leaq 0x33495(%rip), %rdx # 0x63139
leaq -0x998(%rbp), %rsi
callq 0x5d9a0
jmp 0x2fcb2
callq 0x153e0
jmp 0x2fcb9
jmp 0x2fcbb
jmp 0x2fcbd
jmp 0x2fcbf
leaq -0x838(%rbp), %rdi
callq 0x2a5a0
addq $0xa80, %rsp # imm = 0xA80
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x858(%rbp)
movl %eax, -0x85c(%rbp)
callq 0x153e0
jmp 0x2fced
jmp 0x2fcef
leaq -0x838(%rbp), %rdi
callq 0x2a5a0
movq -0x858(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,092 | (anonymous namespace)::TestCheckArrayEqualTrue::~TestCheckArrayEqualTrue() | TEST(CheckArrayEqualTrue)
{
TestResults results;
int const array[3] = { 1, 2, 3 };
CheckArrayEqual(results, array, array, 3, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2cd40
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,093 | (anonymous namespace)::TestCheckArrayEqualTrue::RunImpl() const | TEST(CheckArrayEqualTrue)
{
TestResults results;
int const array[3] = { 1, 2, 3 };
CheckArrayEqual(results, array, array, 3, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
movq 0x33a31(%rip), %rax # 0x63794
movq %rax, -0x2c(%rbp)
movl 0x33a2f(%rip), %eax # 0x6379c
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x3a0dd(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
leaq -0x20(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
movl $0x3, %ecx
leaq -0x50(%rbp), %r8
movq %rdx, %rsi
callq 0x31a30
callq 0x5b060
movq %rax, -0xb0(%rbp)
jmp 0x2fdb0
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movl $0x0, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5da90
movl %eax, -0xb4(%rbp)
jmp 0x2fdd9
movl -0xb4(%rbp), %eax
movl %eax, -0x64(%rbp)
callq 0x5b070
movq %rax, -0xc8(%rbp)
jmp 0x2fdf0
movq -0xc8(%rbp), %rax
movq (%rax), %rsi
leaq -0x88(%rbp), %rdi
movl $0xbe, %edx
callq 0x5d7c0
jmp 0x2fe0d
movq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x64(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1aa10
jmp 0x2fe2a
jmp 0x2feaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xd0(%rbp)
jmp 0x2fe52
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
callq 0x5b070
movq %rax, -0xd8(%rbp)
jmp 0x2fe71
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
leaq -0xa8(%rbp), %rdi
movl $0xbe, %edx
callq 0x5d7c0
jmp 0x2fe8e
movq -0xe0(%rbp), %rdi
leaq 0x32cbf(%rip), %rdx # 0x62b5b
leaq -0xa8(%rbp), %rsi
callq 0x5d9a0
jmp 0x2feaa
callq 0x153e0
jmp 0x2feb1
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x153e0
jmp 0x2fecd
jmp 0x2fecf
movq -0x58(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,094 | (anonymous namespace)::TestCheckArrayEqualFalse::~TestCheckArrayEqualFalse() | TEST(CheckArrayEqualFalse)
{
TestResults results;
int const array1[3] = { 1, 2, 3 };
int const array2[3] = { 1, 2, 2 };
CheckArrayEqual(results, array1, array2, 3, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2cdc0
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,095 | (anonymous namespace)::TestCheckArrayEqualFalse::RunImpl() const | TEST(CheckArrayEqualFalse)
{
TestResults results;
int const array1[3] = { 1, 2, 3 };
int const array2[3] = { 1, 2, 2 };
CheckArrayEqual(results, array1, array2, 3, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
movq 0x33899(%rip), %rax # 0x637cc
movq %rax, -0x2c(%rbp)
movl 0x33897(%rip), %eax # 0x637d4
movl %eax, -0x24(%rbp)
movq 0x33891(%rip), %rax # 0x637d8
movq %rax, -0x38(%rbp)
movl 0x3388f(%rip), %eax # 0x637e0
movl %eax, -0x30(%rbp)
leaq -0x58(%rbp), %rdi
leaq 0x39ef9(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
leaq -0x20(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl $0x3, %ecx
leaq -0x58(%rbp), %r8
callq 0x31a30
callq 0x5b060
movq %rax, -0xb8(%rbp)
jmp 0x2ff95
movq -0xb8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
movl $0x1, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5da90
movl %eax, -0xbc(%rbp)
jmp 0x2ffbe
movl -0xbc(%rbp), %eax
movl %eax, -0x6c(%rbp)
callq 0x5b070
movq %rax, -0xd0(%rbp)
jmp 0x2ffd5
movq -0xd0(%rbp), %rax
movq (%rax), %rsi
leaq -0x90(%rbp), %rdi
movl $0xc8, %edx
callq 0x5d7c0
jmp 0x2fff2
movq -0xc8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x6c(%rbp), %rdx
leaq -0x90(%rbp), %rcx
callq 0x1aa10
jmp 0x3000f
jmp 0x30094
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
movq -0x60(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xd8(%rbp)
jmp 0x30037
movq -0xd8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe8(%rbp)
callq 0x5b070
movq %rax, -0xe0(%rbp)
jmp 0x30056
movq -0xe0(%rbp), %rax
movq (%rax), %rsi
leaq -0xb0(%rbp), %rdi
movl $0xc8, %edx
callq 0x5d7c0
jmp 0x30073
movq -0xe8(%rbp), %rdi
leaq 0x32a63(%rip), %rdx # 0x62ae4
leaq -0xb0(%rbp), %rsi
callq 0x5d9a0
jmp 0x3008f
callq 0x153e0
jmp 0x30096
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x153e0
jmp 0x300b2
jmp 0x300b4
movq -0x60(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,096 | (anonymous namespace)::TestCheckArrayCloseTrue::~TestCheckArrayCloseTrue() | TEST(CheckArrayCloseTrue)
{
TestResults results;
float const array1[3] = { 1.0f, 1.5f, 2.0f };
float const array2[3] = { 1.01f, 1.51f, 2.01f };
CheckArrayClose(results, array1, array2, 3, 0.02f, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2ce40
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,097 | (anonymous namespace)::TestCheckArrayCloseTrue::RunImpl() const | TEST(CheckArrayCloseTrue)
{
TestResults results;
float const array1[3] = { 1.0f, 1.5f, 2.0f };
float const array2[3] = { 1.01f, 1.51f, 2.01f };
CheckArrayClose(results, array1, array2, 3, 0.02f, TestDetails("", "", "", 0));
CHECK_EQUAL(0, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
movq 0x336ed(%rip), %rax # 0x63810
movq %rax, -0x2c(%rbp)
movl 0x336eb(%rip), %eax # 0x63818
movl %eax, -0x24(%rbp)
movq 0x336e5(%rip), %rax # 0x6381c
movq %rax, -0x38(%rbp)
movl 0x336e3(%rip), %eax # 0x63824
movl %eax, -0x30(%rbp)
movss 0x32894(%rip), %xmm0 # 0x629e0
movss %xmm0, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
leaq 0x39cfc(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
leaq -0x20(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl $0x3, %ecx
leaq -0x3c(%rbp), %r8
leaq -0x60(%rbp), %r9
callq 0x31c50
callq 0x5b060
movq %rax, -0xc0(%rbp)
jmp 0x30196
movq -0xc0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd0(%rbp)
movl $0x0, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5da90
movl %eax, -0xc4(%rbp)
jmp 0x301bf
movl -0xc4(%rbp), %eax
movl %eax, -0x74(%rbp)
callq 0x5b070
movq %rax, -0xd8(%rbp)
jmp 0x301d6
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
leaq -0x98(%rbp), %rdi
movl $0xd2, %edx
callq 0x5d7c0
jmp 0x301f3
movq -0xd0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x74(%rbp), %rdx
leaq -0x98(%rbp), %rcx
callq 0x1aa10
jmp 0x30210
jmp 0x30295
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movq -0x68(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xe0(%rbp)
jmp 0x30238
movq -0xe0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xf0(%rbp)
callq 0x5b070
movq %rax, -0xe8(%rbp)
jmp 0x30257
movq -0xe8(%rbp), %rax
movq (%rax), %rsi
leaq -0xb8(%rbp), %rdi
movl $0xd2, %edx
callq 0x5d7c0
jmp 0x30274
movq -0xf0(%rbp), %rdi
leaq 0x328d9(%rip), %rdx # 0x62b5b
leaq -0xb8(%rbp), %rsi
callq 0x5d9a0
jmp 0x30290
callq 0x153e0
jmp 0x30297
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x153e0
jmp 0x302b3
jmp 0x302b5
movq -0x68(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,098 | (anonymous namespace)::TestCheckArrayCloseFalse::~TestCheckArrayCloseFalse() | TEST(CheckArrayCloseFalse)
{
TestResults results;
float const array1[3] = { 1.0f, 1.5f, 2.0f };
float const array2[3] = { 1.01f, 1.51f, 2.01f };
CheckArrayClose(results, array1, array2, 3, 0.001f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2cec0
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
11,099 | (anonymous namespace)::TestCheckArrayCloseFalse::RunImpl() const | TEST(CheckArrayCloseFalse)
{
TestResults results;
float const array1[3] = { 1.0f, 1.5f, 2.0f };
float const array2[3] = { 1.01f, 1.51f, 2.01f };
CheckArrayClose(results, array1, array2, 3, 0.001f, TestDetails("", "", "", 0));
CHECK_EQUAL(1, results.GetFailureCount());
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d910
movq 0x33531(%rip), %rax # 0x63854
movq %rax, -0x2c(%rbp)
movl 0x3352f(%rip), %eax # 0x6385c
movl %eax, -0x24(%rbp)
movq 0x33529(%rip), %rax # 0x63860
movq %rax, -0x38(%rbp)
movl 0x33527(%rip), %eax # 0x63868
movl %eax, -0x30(%rbp)
movss 0x32698(%rip), %xmm0 # 0x629e4
movss %xmm0, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
leaq 0x39afc(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5d780
leaq -0x20(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl $0x3, %ecx
leaq -0x3c(%rbp), %r8
leaq -0x60(%rbp), %r9
callq 0x31c50
callq 0x5b060
movq %rax, -0xc0(%rbp)
jmp 0x30396
movq -0xc0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd0(%rbp)
movl $0x1, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5da90
movl %eax, -0xc4(%rbp)
jmp 0x303bf
movl -0xc4(%rbp), %eax
movl %eax, -0x74(%rbp)
callq 0x5b070
movq %rax, -0xd8(%rbp)
jmp 0x303d6
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
leaq -0x98(%rbp), %rdi
movl $0xdc, %edx
callq 0x5d7c0
jmp 0x303f3
movq -0xd0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x74(%rbp), %rdx
leaq -0x98(%rbp), %rcx
callq 0x1aa10
jmp 0x30410
jmp 0x30495
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movq -0x68(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xe0(%rbp)
jmp 0x30438
movq -0xe0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xf0(%rbp)
callq 0x5b070
movq %rax, -0xe8(%rbp)
jmp 0x30457
movq -0xe8(%rbp), %rax
movq (%rax), %rsi
leaq -0xb8(%rbp), %rdi
movl $0xdc, %edx
callq 0x5d7c0
jmp 0x30474
movq -0xf0(%rbp), %rdi
leaq 0x32662(%rip), %rdx # 0x62ae4
leaq -0xb8(%rbp), %rsi
callq 0x5d9a0
jmp 0x30490
callq 0x153e0
jmp 0x30497
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x153e0
jmp 0x304b3
jmp 0x304b5
movq -0x68(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestChecks.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.