name string | code string | asm string | file string |
|---|---|---|---|
Catch::TestCaseInfo::TestCaseInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::set<std::__cxx11::ba... | TestCaseInfo::TestCaseInfo( std::string const& _name,
std::string const& _className,
std::string const& _description,
std::set<std::string> const& _tags,
SourceLineInfo const& _lineInfo )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %rbp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4042a
leaq 0x20(%r... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::TestCaseInfo::TestCaseInfo(Catch::TestCaseInfo const&) | TestCaseInfo::TestCaseInfo( TestCaseInfo const& other )
: name( other.name ),
className( other.className ),
description( other.description ),
tags( other.tags ),
lcaseTags( other.lcaseTags ),
tagsAsString( other.tagsAsString ),
lineInfo( other.lineInfo ),
pr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
movq 0x20(%r12), %rsi
movq 0x2... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::TestCase::swap(Catch::TestCase&) | void TestCase::swap( TestCase& other ) {
test.swap( other.test );
name.swap( other.name );
className.swap( other.className );
description.swap( other.description );
tags.swap( other.tags );
lcaseTags.swap( other.lcaseTags );
tagsAsString.swap( other.tagsAsString )... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x110(%rdi), %rax
movq 0x110(%rsi), %rcx
movq %rcx, 0x110(%rdi)
movq %rax, 0x110(%rsi)
callq 0x2d2c0
leaq 0x20(%r14), %rdi
leaq 0x20(%rbx), %rsi
callq 0x2d2c0
leaq 0x40(%r14), %rdi
leaq 0x40(%rbx), %rsi
callq 0x... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::TestCase::operator==(Catch::TestCase const&) const | T* get() const{ return m_p; } | movq 0x110(%rdi), %rax
cmpq 0x110(%rsi), %rax
je 0x4460f
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x4465a
testq %rdx, %rdx
je 0x44637
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x2d3d0
testl %eax, %eax
jne 0x4465a
movq 0x28(%rbx),... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::operator<<(std::ostream&, Catch::Version const&) | std::ostream& operator << ( std::ostream& os, Version const& version ) {
os << version.majorVersion << "."
<< version.minorVersion << "."
<< version.patchNumber;
if( !version.branchName.empty() ) {
os << "-" << version.branchName
<< "." << version.b... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x2d270
movq %rax, %r15
leaq 0x25d90(%rip), %r12 # 0x6a496
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2d420
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x2d270
movq %rax, %r15
movl $0x1, %edx
m... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::MessageInfo::MessageInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&, Catch::ResultWas::OfType) | MessageInfo::MessageInfo( std::string const& _macroName,
SourceLineInfo const& _lineInfo,
ResultWas::OfType _type )
: macroName( _macroName ),
lineInfo( _lineInfo ),
type( _type ),
sequence( ++globalCount )
{} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4042a
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%r14), %rsi
movq 0x8... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ScopedMessage::ScopedMessage(Catch::MessageBuilder const&) | ScopedMessage::ScopedMessage( MessageBuilder const& builder )
: m_info( builder.m_info )
{
m_info.message = builder.m_stream.str();
getResultCapture().pushScopedMessage( m_info );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %rbp
movq %rbp, 0x20(%rbx)
movq 0x20(%r14), %rsi
movq 0x2... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ScopedMessage::ScopedMessage(Catch::ScopedMessage const&) | ScopedMessage::ScopedMessage( ScopedMessage const& other )
: m_info( other.m_info )
{} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rd... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ScopedMessage::~ScopedMessage() | ScopedMessage::~ScopedMessage() {
getResultCapture().popScopedMessage( m_info );
} | pushq %rbx
movq %rdi, %rbx
callq 0x41964
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x38(%rcx)
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x44a0f
callq 0x2d360
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x44a21
callq 0x2d360
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::LegacyReporterAdapter::assertionEnded(Catch::AssertionStats const&) | bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) {
if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x368, %rsp # imm = 0x368
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
cmpl $0x0, 0xb8(%rsi)
je 0x44bce
movq 0x8(%rsp), %rax
movq 0xc0(%rax), %r15
movq 0xc8(%rax), %rbx
cmpq %rbx, %r15
je 0x44bce
leaq 0x25655(%rip), %r12 # 0x6a1a0
leaq 0xc8(... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::LegacyReporterAdapter::testCaseEnded(Catch::TestCaseStats const&) | T* operator->() const { return m_p; } | movq 0x10(%rdi), %rdi
leaq 0x8(%rsi), %rax
leaq 0x118(%rsi), %rdx
leaq 0x148(%rsi), %rcx
leaq 0x168(%rsi), %r8
movq (%rdi), %rsi
movq 0x50(%rsi), %r9
movq %rax, %rsi
jmpq *%r9
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string trim( std::string const& str ) {
static char const* whitespaceChars = "\n\r\t ";
std::string::size_type start = str.find_first_not_of( whitespaceChars );
std::string::size_type end = str.find_last_not_of( whitespaceChars );
return start != std::string::npos ? str.substr( sta... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x23fd4(%rip), %r12 # 0x690ee
movl $0x4, %ecx
movq %rsi, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2d610
movq %rax, %r15
movl $0x4, %ecx
movq %r14, %rdi
movq %r12, %rsi
movq $-0x1, %rdx
callq 0x2d5e0
cmpq $-0x1, %r15
je 0... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::replaceInPlace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
bool replaced = false;
std::size_t i = str.find( replaceThis );
while( i != std::string::npos ) {
replaced = true;
str = str.substr( 0, i ) + withThis + str.substr( i+re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r15
movq (%rsi), %rsi
movq %rax, 0x10(%rsp)
movq 0x8(%rax), %rcx
xorl %edx, %edx
callq 0x2d660
movq %rax, 0x8(%rsp)
cmpq $-0x1, %rax
je 0x453a1
leaq 0x48(%rsp), %rbp
leaq 0x68(%rsp), %r13
movq ... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::operator<<(std::ostream&, Catch::pluralise const&) | std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
os << pluraliser.m_count << " " << pluraliser.m_label;
if( pluraliser.m_count != 1 )
os << "s";
return os;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0x2d270
movq %rax, %r15
leaq 0x23ca7(%rip), %rsi # 0x690f1
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0x2d420
cmpq $0x1, (%r14)
je 0x45481
leaq 0x2414a(%rip), ... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::SourceLineInfo::SourceLineInfo(Catch::SourceLineInfo const&) | SourceLineInfo::SourceLineInfo( SourceLineInfo const& other )
: file( other.file ),
line( other.line )
{} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
callq 0x4042a
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::SourceLineInfo::operator==(Catch::SourceLineInfo const&) const | bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const {
return line == other.line && file == other.file;
} | movq 0x20(%rdi), %rax
cmpq 0x20(%rsi), %rax
jne 0x45529
movq 0x8(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x45529
testq %rdx, %rdx
je 0x4552c
pushq %rax
movq (%rsi), %rsi
movq (%rdi), %rdi
callq 0x2d3d0
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::rngSeed() | IContext& getCurrentContext() {
return getCurrentMutableContext();
} | pushq %rbx
subq $0x10, %rsp
callq 0x4376b
movq (%rax), %rcx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x30(%rcx)
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x455a9
movq (%rdi), %rax
callq *0x18(%rax)
movl %ebx, %eax
addq $0x10, %rsp
p... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::throwLogicError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&) | void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) {
std::ostringstream oss;
oss << locationInfo << ": Internal Catch error: '" << message << "'";
if( alwaysTrue() )
throw std::logic_error( oss.str() );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x2d4b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x42ab1
leaq 0x23aeb(%rip), %rsi # 0x690f3
leaq 0x20(%rsp), %rdi
movl $0x19, %edx
callq 0x2d420
movq (%rbx)... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::SectionInfo::SectionInfo(Catch::SourceLineInfo const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | SectionInfo::SectionInfo
( SourceLineInfo const& _lineInfo,
std::string const& _name,
std::string const& _description )
: name( _name ),
description( _description ),
lineInfo( _lineInfo )
{} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %rbp
movq %rbp, 0x20(%rbx)
movq (%r12), %rsi
mo... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Section::Section(Catch::SectionInfo const&) | Section::Section( SectionInfo const& info )
: m_info( info ),
m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
{
m_timer.start();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x3a335(%rip), %rax # 0x7fac8
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4042a... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Section::~Section() | Section::~Section() {
if( m_sectionIncluded ) {
SectionEndInfo endInfo( m_info, m_assertions, m_timer.getElapsedSeconds() );
if( std::uncaught_exception() )
getResultCapture().sectionEndedEarly( endInfo );
else
getResultCapture().sectionEnded( ... | pushq %rbx
movq %rdi, %rbx
callq 0x458c2
movq %rbx, %rdi
popq %rbx
jmp 0x2d360
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::Detail::rawMemoryToString[abi:cxx11](void const*, unsigned long) | std::string rawMemoryToString( const void *object, std::size_t size )
{
// Reverse order for little endian architectures
int i = 0, end = static_cast<int>( size ), inc = 1;
if( Endianness::which() == Endianness::Little ) {
i = end-1;
end = inc = -1;
}
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x2d4b0
leaq 0x236ec(%rip), %rsi # 0x69127
movl $0x2, %edx
movq %r12, %rdi
callq 0x2d420
movq (%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%r... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::toString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string toString( std::string const& value ) {
std::string s = value;
if( getCurrentContext().getConfig()->showInvisibles() ) {
for(size_t i = 0; i < s.size(); ++i ) {
std::string subs;
switch( s[i] ) {
case '\n': subs = "\\n"; break;
case '\t': subs =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0x90(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x80(%rsp), %rdi
movq %rax, %rsi
callq 0x4042a
callq 0x4376b
movq (%rax), %rcx
movq %rsp, %rdi
movq %rax, %rsi
callq... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::toString[abi:cxx11](int) | std::string toString( int value ) {
std::ostringstream oss;
oss << value;
if( value > Detail::hexThreshold )
oss << " (0x" << std::hex << value << ")";
return oss.str();
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2d4b0
movq %r14, %rdi
movl %ebp, %esi
callq 0x2d650
cmpl $0x100, %ebp # imm = 0x100
jl 0x461f5
leaq 0x22f74(%rip), %rsi # 0x69125
leaq 0x8(%rsp), %rdi
m... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::toString[abi:cxx11](unsigned long) | std::string toString( unsigned long value ) {
std::ostringstream oss;
oss << value;
if( value > Detail::hexThreshold )
oss << " (0x" << std::hex << value << ")";
return oss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2d4b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d270
cmpq $0x100, %r14 # imm = 0x100
jb 0x462d1
leaq 0x22e99(%rip), %rsi # 0x69125
leaq 0x8(%rsp), %rdi
m... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::toString[abi:cxx11](float) | std::string toString( const float value ) {
return fpToString( value, 5 ) + "f";
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x5, %esi
callq 0x4a39d
leaq 0x23431(%rip), %rsi # 0x697a6
movq %r14, %rdi
callq 0x2d700
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x4639f
movq %rsi, ... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::toString[abi:cxx11](bool) | std::string toString( bool value ) {
return value ? "true" : "false";
} | pushq %rbx
movq %rdi, %rbx
leaq 0x22d27(%rip), %rcx # 0x6912a
leaq 0x22d51(%rip), %rax # 0x6915b
testl %esi, %esi
cmovneq %rcx, %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movl %esi, %edx
xorq $0x5, %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x3ef3e
movq %rbx, %rax
popq %rbx
retq
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::toString[abi:cxx11](unsigned long long) | std::string toString( unsigned long long value ) {
std::ostringstream oss;
oss << value;
if( value > Detail::hexThreshold )
oss << " (0x" << std::hex << value << ")";
return oss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2d4b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d260
cmpq $0x100, %r14 # imm = 0x100
jb 0x465e2
leaq 0x22b88(%rip), %rsi # 0x69125
leaq 0x8(%rsp), %rdi
m... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::TestGroupStats::~TestGroupStats() | TestGroupStats::~TestGroupStats() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x3773d(%rip), %rax # 0x7fb78
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x48450
callq 0x2d360
movq %rbx, %rdi
popq %rbx
jmp 0x2d360
nop
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::WildcardPattern::~WildcardPattern() | WildcardPattern::~WildcardPattern() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x376f1(%rip), %rax # 0x7fe90
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x487b4
callq 0x2d360
movq %rbx, %rdi
popq %rbx
jmp 0x2d360
nop
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::TestSpec::NamePattern::~NamePattern() | TestSpec::NamePattern::~NamePattern() {} | movq %rdi, %rax
leaq 0x376ec(%rip), %rcx # 0x7feb8
movq %rcx, (%rdi)
leaq 0x376ba(%rip), %rcx # 0x7fe90
movq %rcx, 0x10(%rdi)
movq 0x20(%rdi), %rdi
addq $0x30, %rax
cmpq %rax, %rdi
jne 0x2d360
retq
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::TestSpec::NamePattern::~NamePattern() | TestSpec::NamePattern::~NamePattern() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x376c1(%rip), %rax # 0x7feb8
movq %rax, (%rdi)
leaq 0x3768f(%rip), %rax # 0x7fe90
movq %rax, 0x10(%rdi)
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x48817
callq 0x2d360
movq %rbx, %rdi
popq %rbx
jmp 0x2d360
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::TestSpec::TagPattern::~TagPattern() | TestSpec::TagPattern::~TagPattern() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x376a5(%rip), %rax # 0x7fef0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x48860
callq 0x2d360
movq %rbx, %rdi
popq %rbx
jmp 0x2d360
nop
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::(anonymous namespace)::PosixColourImpl::~PosixColourImpl() | virtual void use( Colour::Code _colourCode ) {
switch( _colourCode ) {
case Colour::None:
case Colour::White: return setColour( "[0m" );
case Colour::Red: return setColour( "[0;31m" );
case Colour::Green: return setColour( "[0;32m... | jmp 0x2d360
nop
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::(anonymous namespace)::PosixColourImpl::use(Catch::Colour::Code) | virtual void use( Colour::Code _colourCode ) {
switch( _colourCode ) {
case Colour::None:
case Colour::White: return setColour( "[0m" );
case Colour::Red: return setColour( "[0;31m" );
case Colour::Green: return setColour( "[0;32m... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x17, %esi
ja 0x48d05
movl %esi, %eax
leaq 0x1fb56(%rip), %rcx # 0x687e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x20787(%rip), %rdi # 0x69429
jmp 0x48cfc
leaq 0x207b3(%rip), %rdi # 0x6945e
jmp 0x48cfc
leaq 0x207a3(%rip), %rdi # 0x69457
jmp 0x48c... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::(anonymous namespace)::PosixColourImpl::setColour(char const*) | void setColour( const char* _escapeCode ) {
Catch::cout() << '\033' << _escapeCode;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7(%rsp), %rsi
movb $0x1b, (%rsi)
movq 0x39258(%rip), %rdi # 0x81fc0
movl $0x1, %edx
callq 0x2d420
movq %rax, %r14
testq %rbx, %rbx
je 0x48d92
movq %rbx, %rdi
callq 0x2d180
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2d420
jmp 0x48dac
movq (%r14), %... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Ptr<Catch::IStreamingReporter>::operator=(Catch::Ptr<Catch::IStreamingReporter> const&) | Ptr& operator = ( Ptr const& other ){
Ptr temp( other );
swap( temp );
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
testq %r14, %r14
je 0x48dd0
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0x48de1
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::RunContext::RunContext(Catch::Ptr<Catch::IConfig const> const&, Catch::Ptr<Catch::IStreamingReporter> const&) | explicit RunContext( Ptr<IConfig const> const& _config, Ptr<IStreamingReporter> const& reporter )
: m_runInfo( _config->name() ),
m_context( getCurrentMutableContext() ),
m_activeTestCase( CATCH_NULL ),
m_config( _config ),
m_reporter( reporter )
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3835a(%rip), %rax # 0x81258
movq %rax, (%rdi)
leaq 0x383c0(%rip), %rax # 0x812c8
movq %rax, 0x8(%rdi)
movq (%rsi), %rsi
movq (%rsi), %rax
leaq 0x18(%rsp), %rdi
callq *0x30(%r... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::enforceNotReservedTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&) | inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
if( isReservedTag( tag ) ) {
{
Colour colourGuard( Colour::Red );
Catch::cerr()
<< "Tag name [" << tag << "] not allowed.\n"
<< "Tag ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x49e22
testl %eax, %eax
jne 0x49f4c
cmpq $0x0, 0x8(%r14)
je 0x49f4c
movq (%r14), %rax
movsbl (%rax), %edi
callq 0x2d3c0
testl %eax, %eax
je 0x49f54
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x0, 0x7(%rsp)
movl $0x2, %edi
callq 0x437d0
movq 0x3... | /dillonhuff[P]bsim/test/catch.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::fpToString<float>(float, int) | std::string fpToString( T value, int precision ) {
std::ostringstream oss;
oss << std::setprecision( precision )
<< std::fixed
<< value;
std::string d = oss.str();
std::size_t i = d.find_last_not_of( '0' );
if( i != std::string::npos && i != d.size()-1 ) {
if( d[i] == '.' )
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movl %esi, %ebp
movss %xmm0, 0x4(%rsp)
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2d4b0
movq (%r14), %rax
movq -0x18(%rax), %rax
movslq %ebp, %rcx
movq %rcx, 0x30(%rsp,%rax)
movq (%r14), %rax
movq -0x18(%rax), %rax
movl $0xff... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ReporterRegistrar<Catch::JunitReporter>::ReporterRegistrar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ReporterRegistrar( std::string const& name ) {
getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x42d35
movq %rax, %r14
movl $0x10, %edi
callq 0x2d3a0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movl $0x0, 0x8(%rax)
leaq 0x3754f(%rip), %rcx # 0x81c60
movq %rcx, (%rax)
movq %rsp, %rdx
movq %rax, (%rdx)
movl $0x1, 0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
mov... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Session::Session() | Session()
: m_cli( makeCommandLineParser() ) {
if( alreadyInstantiated ) {
std::string msg = "Only one instance of Catch::Session can ever be used";
Catch::cerr() << msg << std::endl;
throw std::logic_error( msg );
}
alreadyInst... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x36bf9(%rip), %rax # 0x81650
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x54884
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%r14)
movups %xmm0, 0x68(%r14)
movl $0x0, 0x87(%r14)
movaps 0x1dceb(%rip), %xmm1 # ... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Matchers::Impl::StdString::Contains::toString[abi:cxx11]() const | virtual std::string toString() const {
return "contains: \"" + m_data.m_str + "\"" + m_data.toStringSuffix();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdx
leaq 0x1ed80(%rip), %rsi # 0x69d6a
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x49917
leaq 0x1e07e(%rip), %rsi # 0x6907c
movq %r15, %rdi
callq 0x2d700
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax)... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::TestCaseTracking::TrackerBase::name[abi:cxx11]() const | virtual std::string name() const CATCH_OVERRIDE {
return m_name;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4042a
movq %rbx, %rax
popq %rbx
retq
nop
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::JunitReporter::testGroupEnded(Catch::TestGroupStats const&) | virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
double suiteTime = suiteTimer.getElapsedSeconds();
CumulativeReporterBase::testGroupEnded( testGroupStats );
writeGroup( *m_testGroups.back(), suiteTime );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x2d5c0
imull $0xf4240, (%r15), %eax # imm = 0xF4240
addl 0x8(%r15), %eax
subl 0x110(%r14), %eax
cvtsi2sd %rax, %xmm0
divsd 0x1a5f5(%rip), %xmm0 # 0x68760
movsd %xmm0, 0x8(%r... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::noMatchingTestCases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE {
stream << "No test cases matched '" << spec << "'" << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rdi), %r14
leaq 0x1bf93(%rip), %rsi # 0x6a14d
movl $0x17, %edx
movq %r14, %rdi
callq 0x2d420
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2d420
movq %rax, %rbx
leaq 0x1b7ff(%rip), %rsi # 0x699df
movl $0x1, %edx
movq %rax, %rdi
callq 0... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::assertionEnded(Catch::AssertionStats const&) | virtual bool assertionEnded( AssertionStats const& _assertionStats ) CATCH_OVERRIDE {
AssertionResult const& result = _assertionStats.assertionResult;
bool printInfoMessages = true;
// Drop out if result was successful and we're not printing those
if( !m_config->include... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x4e275
movl 0xb8(%r14), %eax
testb $0x10, %al
je 0x4e26a
movl 0x70(%r14), %ecx
andl $0x8, %ecx
je 0x4e275
xorl %ebp, %ebp
cmpl $0x2, ... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::sectionEnded(Catch::SectionStats const&) | virtual void sectionEnded( SectionStats const& _sectionStats ) CATCH_OVERRIDE {
if( _sectionStats.missingAssertions ) {
lazyPrint();
Colour colour( Colour::ResultError );
if( m_sectionStack.size() > 1 )
stream << "\nNo assertions in section... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x90(%rsi)
jne 0x4e424
movq %rbx, %rdi
callq 0x611c0
movb $0x0, 0x7(%rsp)
movl $0x12, %edi
callq 0x437d0
movq 0x1b8(%rbx), %rax
subq 0x1b0(%rbx), %rax
movq 0x18(%rbx), %rdi
sarq $0x3, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %rcx... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::testGroupEnded(Catch::TestGroupStats const&) | virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) CATCH_OVERRIDE {
if( currentGroupInfo.used ) {
printSummaryDivider();
stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
printTotals( _testGroupStats.totals );
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x88(%rdi)
jne 0x4e63c
movq %rsi, %r14
movq %rbx, %rdi
callq 0x622b8
movq 0x18(%rbx), %r15
leaq 0x1bd9b(%rip), %rsi # 0x6a358
movl $0x13, %edx
movq %r15, %rdi
callq 0x2d420
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0x2d420
leaq 0x1bd... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::testRunEnded(Catch::TestRunStats const&) | virtual void testRunEnded( TestRunStats const& _testRunStats ) CATCH_OVERRIDE {
printTotalsDivider( _testRunStats.totals );
printTotals( _testRunStats.totals );
stream << std::endl;
StreamingReporterBase::testRunEnded( _testRunStats );
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsi), %r15
movq %r15, %rsi
callq 0x63156
movq %r14, %rdi
movq %r15, %rsi
callq 0x62332
movq 0x18(%r14), %r15
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %r15, %rdi
callq 0x2d030
m... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::CompactReporter::noMatchingTestCases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | virtual void noMatchingTestCases( std::string const& spec ) {
stream << "No test cases matched '" << spec << "'" << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rdi), %r14
leaq 0x1ba6d(%rip), %rsi # 0x6a14d
movl $0x17, %edx
movq %r14, %rdi
callq 0x2d420
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2d420
movq %rax, %rbx
leaq 0x1b2d9(%rip), %rsi # 0x699df
movl $0x1, %edx
movq %rax, %rdi
callq 0... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::CompactReporter::assertionEnded(Catch::AssertionStats const&) | virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
AssertionResult const& result = _assertionStats.assertionResult;
bool printInfoMessages = true;
// Drop out if result was successful and we're not printing those
if( !m_config->includeSuccessfulResul... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x4e780
movl 0xb8(%r15), %eax
testb $0x10, %al
je 0x4e779
movl 0x70(%r15), %ecx
andl $0x8, %ecx
je 0x4e780
xorl %ebp, %ebp
cmpl $0x2, ... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::RunContext::assertionEnded(Catch::AssertionResult const&) | virtual void assertionEnded( AssertionResult const& result ) {
if( result.getResultType() == ResultWas::Ok ) {
m_totals.assertions.passed++;
}
else if( !result.isOk() ) {
m_totals.assertions.failed++;
}
if( m_reporter->assertio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rsi, %rbx
movq %rdi, %r14
movl 0xb0(%rsi), %eax
testl %eax, %eax
je 0x4ea2e
testb $0x10, %al
je 0x4ea37
movl 0x68(%rbx), %ecx
movl $0x118, %eax # imm = 0x118
andl $0x8, %ecx
je 0x4ea33
jmp 0x4ea... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::RunContext::sectionEnded(Catch::SectionEndInfo const&) | virtual void sectionEnded( SectionEndInfo const& endInfo ) {
Counts assertions = m_totals.assertions - endInfo.prevAssertions;
bool missingAssertions = testForMissingAssertions( assertions );
if( !m_activeSections.empty() ) {
m_activeSections.back()->close();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movdqu 0x110(%rdi), %xmm0
movdqu 0x68(%r14), %xmm1
psubq %xmm1, %xmm0
movdqa %xmm0, (%rsi)
movq 0x120(%rdi), %rax
subq 0x78(%r14), %rax
mo... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::RunContext::sectionEndedEarly(Catch::SectionEndInfo const&) | virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) {
if( m_unfinishedSections.empty() )
m_activeSections.back()->fail();
else
m_activeSections.back()->close();
m_activeSections.pop_back();
m_unfinishedSections.push_back( endIn... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1d0(%rdi), %r15
movq 0x1d0(%rdi), %rax
xorl %ecx, %ecx
cmpq 0x1d8(%rdi), %rax
movq 0x1f0(%rdi), %rax
sete %cl
movq -0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax,%rcx,8)
addq $-0x8, 0x1f0(%r14)
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::AssertionStats::AssertionStats(Catch::AssertionResult const&, std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>> const&, Catch::Totals const&) | AssertionStats( AssertionResult const& _assertionResult,
std::vector<MessageInfo> const& _infoMessages,
Totals const& _totals )
: assertionResult( _assertionResult ),
infoMessages( _infoMessages ),
totals( _totals )
{
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x240, %rsp # imm = 0x240
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r15
leaq 0x306a8(%rip), %rax # 0x7fb18
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x4f71e
leaq 0xc0(%r15), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x4f83... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::AssertionResult::AssertionResult(Catch::AssertionResult const&) | AssertionResult( AssertionResult const& ) = default; | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rd... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::MessageBuilder::~MessageBuilder() | MessageBuilder( std::string const& macroName,
SourceLineInfo const& lineInfo,
ResultWas::OfType type )
: m_info( macroName, lineInfo, type )
{} | pushq %rbx
movq %rdi, %rbx
addq $0x78, %rdi
movq 0x3267b(%rip), %rsi # 0x81fb0
callq 0x2d1d0
leaq 0xe8(%rbx), %rdi
callq 0x2d110
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x4f958
callq 0x2d360
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x4f96a
callq 0x2d360
movq (%rbx), %rdi... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::TestCaseTracking::SectionTracker::acquire(Catch::TestCaseTracking::TrackerContext&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static SectionTracker& acquire( TrackerContext& ctx, std::string const& name ) {
SectionTracker* section = CATCH_NULL;
ITracker& currentTracker = ctx.currentTracker();
if( ITracker* childTracker = currentTracker.findChild( name ) ) {
section = dynamic_cast<SectionTra... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x70(%rax)
testq %rax, %rax
je 0x4ff2b
leaq 0x30529(%rip), %rsi # 0x80418
leaq 0x305e2(%rip), %rdx # 0x804d8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x2d410
movq %ra... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::RunContext::testForMissingAssertions(Catch::Counts&) | std::size_t total() const {
return passed + failed + failedButOk;
} | movq 0x8(%rsi), %rax
addq (%rsi), %rax
addq 0x10(%rsi), %rax
jne 0x5018f
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x108(%rdi), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
je 0x5018b
movq 0x208(%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testb %al, %al
je 0x50192
xorl %eax, %... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::SectionStats::SectionStats(Catch::SectionInfo const&, Catch::Counts const&, double, bool) | SectionStats( SectionInfo const& _sectionInfo,
Counts const& _assertions,
double _durationInSeconds,
bool _missingAssertions )
: sectionInfo( _sectionInfo ),
assertions( _assertions ),
durationInSeconds( _duratio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movsd %xmm0, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x2f96a(%rip), %rax # 0x7fb38
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r14), %rax
movq %rax, (%rsp)
movq %rax, 0x8(%r14)
movq (%rsi), %r... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::RunContext::handleUnfinishedSections() | void handleUnfinishedSections() {
// If sections ended prematurely due to an exception we stored their
// infos here so we can tear them down outside the unwind process.
for( std::vector<SectionEndInfo>::const_reverse_iterator it = m_unfinishedSections.rbegin(),
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1d0(%rdi), %rbx
movq 0x1d0(%rdi), %r12
movq 0x1d8(%rdi), %r15
cmpq %r12, %r15
je 0x508d5
movq %rdi, %r14
addq $-0x88, %r15
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%rax)
cmpq %r12, %r15
jne 0x508bd
movq (%rbx), %rsi
movq %rbx, %rdi
addq ... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::TestCaseStats::TestCaseStats(Catch::TestCaseInfo const&, Catch::Totals const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | TestCaseStats( TestCaseInfo const& _testInfo,
Totals const& _totals,
std::string const& _stdOut,
std::string const& _stdErr,
bool _aborting )
: testInfo( _testInfo ),
totals( _totals ),
stdOu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %r14
leaq 0x2f24b(%rip), %rax # 0x7fb58
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, (%rsp)
callq 0x4420a
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::TestSpecParser::visitChar(char) | void visitChar( char c ) {
if( m_mode == None ) {
switch( c ) {
case ' ': return;
case '~': m_exclusion = true; return;
case '[': return startNewMode( Tag, ++m_pos );
case '"': return startNewMode( QuotedName, ++m_pos );
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x50cf9
movl (%rbx), %eax
cmpl $0x1, %eax
jne 0x50d2a
movsbl %sil, %eax
cmpl $0x5b, %eax
je 0x50d87
cmpl $0x2c, %eax
jne 0x50dfe
movq %rbx, %rdi
callq 0x50e08
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x50fdc... | /dillonhuff[P]bsim/test/catch.hpp |
void Catch::TestSpecParser::addPattern<Catch::TestSpec::NamePattern>() | void addPattern() {
std::string token = subString();
if( startsWith( token, "exclude:" ) ) {
m_exclusion = true;
token = token.substr( 8 );
}
if( !token.empty() ) {
Ptr<TestSpec::Pattern> pattern = new T( token );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
subq %rdx, %rcx
leaq 0x28(%rsp), %rdi
callq 0x2d3e0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x185a9(%rip), %rsi # 0x693e7
leaq 0x185aa(%rip), %rdx # 0x693ef
lea... | /dillonhuff[P]bsim/test/catch.hpp |
void Catch::TestSpecParser::addPattern<Catch::TestSpec::TagPattern>() | void addPattern() {
std::string token = subString();
if( startsWith( token, "exclude:" ) ) {
m_exclusion = true;
token = token.substr( 8 );
}
if( !token.empty() ) {
Ptr<TestSpec::Pattern> pattern = new T( token );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
subq %rdx, %rcx
leaq 0x28(%rsp), %rdi
callq 0x2d3e0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x18355(%rip), %rsi # 0x693e7
leaq 0x18356(%rip), %rdx # 0x693ef
lea... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::RunContext::runCurrentTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
m_reporter->sectionStarting( te... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4e8, %rsp # imm = 0x4E8
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %rbx
movq 0x38(%rdi), %r14
leaq 0xe0(%r14), %r13
leaq 0x40(%r14), %rcx
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x456d2
movq 0x140(... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Totals::delta(Catch::Totals const&) const | Totals delta( Totals const& prevTotals ) const {
Totals diff = *this - prevTotals;
if( diff.assertions.failed > 0 )
++diff.testCases.failed;
else if( diff.assertions.failedButOk > 0 )
++diff.testCases.failedButOk;
else
++dif... | pushq %rbx
movq %rdi, %rbx
callq 0x5218c
xorl %eax, %eax
cmpq $0x0, 0x10(%rbx)
setne %al
shll $0x4, %eax
addq $0x18, %rax
cmpq $0x0, 0x8(%rbx)
movl $0x20, %ecx
cmoveq %rax, %rcx
incq (%rbx,%rcx)
movq %rbx, %rax
popq %rbx
retq
nop
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::StreamRedirect::StreamRedirect(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | StreamRedirect( std::ostream& stream, std::string& targetString )
: m_stream( stream ),
m_prevBuf( stream.rdbuf() ),
m_targetString( targetString )
{
stream.rdbuf( m_oss.rdbuf() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, (%rdi)
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rsi,%rax), %rax
movq %rax, 0x8(%rdi)
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x2d4b0
movq %r15, 0x188(%rbx)
movq (%r12), %rax
addq -0x18(%rax),... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::RunContext::invokeActiveTestCase() | void invokeActiveTestCase() {
FatalConditionHandler fatalConditionHandler; // Handle signals
m_activeTestCase->invoke();
fatalConditionHandler.reset();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x3041d(%rip), %r15 # 0x823d0
leaq 0x102(%rip), %r14 # 0x520bc
movl (%r12,%r15), %edi
movq %r14, %rsi
callq 0x2d450
addq $0x10, %r12
cmpq $0x60, %r12
jne 0x51fba
movq 0x38(%rbx), %rax
movq 0x110(%rax), %rdi
movq (%rd... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::StreamRedirect::~StreamRedirect() | ~StreamRedirect() {
m_targetString += m_oss.str();
m_stream.rdbuf( m_prevBuf );
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
leaq 0x18(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2d5a0
movq 0x188(%r14), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x2d100
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52059
callq 0x2d360
movq (%r14), %rdi
mo... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::FatalConditionHandler::handleSignal(int) | static void handleSignal( int sig ) {
for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
if( sig == signalDefs[i].id )
fatal( signalDefs[i].name, -sig );
fatal( "<unknown signal>", -sig );
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movl $0x8, %eax
leaq 0x302ff(%rip), %rcx # 0x823d0
cmpl %ebx, -0x8(%rax,%rcx)
je 0x52120
addq $0x10, %rax
cmpq $0x68, %rax
jne 0x520d1
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x17310(%rip), %rsi # 0x69401
leaq 0x17319(%rip), %rdx # 0x69411
lea... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Totals::operator-(Catch::Totals const&) const | Totals operator - ( Totals const& other ) const {
Totals diff;
diff.assertions = assertions - other.assertions;
diff.testCases = testCases - other.testCases;
return diff;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movdqu (%rsi), %xmm0
movdqu (%rdx), %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, (%rdi)
movdqu 0x10(%rsi), %xmm0
movdqu 0x10(%rdx), %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x10(%rdi)
movdqu 0x20(%rsi), %xmm0
movdqu 0x20(%... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ReporterRegistry::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Ptr<Catch::IConfig const> const&) const | virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const CATCH_OVERRIDE {
FactoryMap::const_iterator it = m_factories.find( name );
if( it == m_factories.end() )
return CATCH_NULL;
return it->second->create( ReporterConfig... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x52664
addq $0x10, %rbx
cmpq %rbx, %rax
je 0x5259f
movq 0x40(%rax), %rbx
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, 0x8(%rsp)
movq (%r14), %rdi
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x5257c
movq (%rdi... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() | ~ExceptionTranslatorRegistry() {
deleteAll( m_translators );
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2ed05(%rip), %rax # 0x813e0
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0x526ff
movq (%r14), %rdi
testq %rdi, %rdi
je 0x526f9
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x526e6
movq 0x8(%rbx), %rdi
testq %rdi, %r... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ExceptionTranslatorRegistry::translateActiveException[abi:cxx11]() const | virtual std::string translateActiveException() const {
try {
#ifdef __OBJC__
// In Objective-C try objective-c exceptions first
@try {
return tryTranslators();
}
@catch (NSException *exception) {
return C... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x52856
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rdi
cmpl $0x5, %r14d
je 0x527e1
cmpl $0x4, %r14d
jne 0x52777
callq 0x2d170
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
movq %ra... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ExceptionTranslatorRegistry::tryTranslators[abi:cxx11]() const | Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{} | pushq %rbx
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rcx
cmpq %rcx, %rdx
je 0x52879
movq %rdi, %rbx
movq (%rdx), %rsi
addq $0x8, %rdx
movq (%rsi), %rax
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
retq
callq 0x2d520
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::ReporterRegistry::registerReporter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Ptr<Catch::IReporterFactory> const&) | void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) {
m_factories.insert( std::make_pair( name, factory ) );
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x8, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x52c9c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52a4e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x529e8
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x529fb... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Context::getGeneratorsForCurrentTest() | IGeneratorsForTest& getGeneratorsForCurrentTest() {
IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
if( !generators ) {
std::string testName = getResultCapture()->getCurrentTestName();
generators = createGeneratorsForTest();
m_gene... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
callq 0x531e2
movq %rax, %rbx
testq %rax, %rax
jne 0x531a1
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rax), %rcx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq *0x40(%rcx)
movl $0x50, %edi
callq 0x2d3a0
movq %rax, %rbx
xorps %xmm0, %xmm0
mova... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Context::findGeneratorsForCurrentTest() | IGeneratorsForTest* findGeneratorsForCurrentTest() {
std::string testName = getResultCapture()->getCurrentTestName();
std::map<std::string, IGeneratorsForTest*>::const_iterator it =
m_generatorsByTestName.find( testName );
return it != m_generatorsByTestName.end()
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rax), %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *0x40(%rcx)
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x5325c
addq $0x28, %rbx
cmpq %rbx, %rax
je 0x5321e
movq 0x40(%rax), %rbx
jmp 0x53220
xorl %ebx,... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Ptr<Catch::IConfig const>::operator=(Catch::Ptr<Catch::IConfig const> const&) | Ptr& operator = ( Ptr const& other ){
Ptr temp( other );
swap( temp );
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
testq %r14, %r14
je 0x534a8
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0x534b9
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::GeneratorsForTest::~GeneratorsForTest() | ~GeneratorsForTest() {
deleteAll( m_generatorsInOrder );
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2dfd5(%rip), %rax # 0x814b0
movq %rax, (%rdi)
movq 0x38(%rdi), %r14
movq 0x40(%rdi), %r15
cmpq %r15, %r14
je 0x534ff
movq (%r14), %rdi
testq %rdi, %rdi
je 0x534f9
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x534e6
movq 0x38(%rbx), %rdi
testq %rdi, ... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::GeneratorsForTest::getGeneratorInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) {
std::map<std::string, IGeneratorInfo*>::const_iterator it = m_generatorsByName.find( fileInfo );
if( it == m_generatorsByName.end() ) {
IGeneratorInfo* info = new GeneratorInfo( size );
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x536e4
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0x53562
movq 0x40(%rax), %rax
jmp 0x535fa
movl $0x18, %edi
callq 0x2d3a0
leaq 0x2df85(%rip), %rcx # 0x814f8
movq %r... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::GeneratorsForTest::moveNext() | Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{} | pushq %r15
pushq %r14
pushq %rbx
movq 0x38(%rdi), %r14
movq 0x40(%rdi), %r15
cmpq %r15, %r14
setne %bl
je 0x5365f
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x5365f
addq $0x8, %r14
cmpq %r15, %r14
setne %bl
je 0x5365f
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %r14
te... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Matchers::Impl::MatcherImpl<Catch::Matchers::Impl::Generic::AllOf<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::clone() const | virtual Ptr<Matcher<ExpressionT> > clone() const {
return Ptr<Matcher<ExpressionT> >( new DerivedT( static_cast<DerivedT const&>( *this ) ) );
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x28, %edi
callq 0x2d3a0
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x2d794(%rip), %rax # 0x81540
movq %rax, (%r14)
leaq 0x10(%r14), %rdi
addq $0x10, %r15
movq %r15, %rsi
callq 0x53fdc
movq %r14, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Matchers::Impl::Generic::AllOf<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::toString() const | virtual std::string toString() const {
std::ostringstream oss;
oss << "( ";
for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
if( i != 0 )
oss << " and ";
oss << m_matchers[i]->toString();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x2d4b0
leaq 0x15424(%rip), %rsi # 0x6929f
movl $0x2, %edx
movq %r15, %rdi
callq 0x2d420
movq %rbx, 0x8(%rsp)
movq 0x18(%r14), %rax... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Matchers::Impl::StdString::CasedString::adjustString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string adjustString( std::string const& str ) const {
return m_caseSensitivity == CaseSensitive::No
? toLower( str )
: str;
} | pushq %rbx
movq %rdi, %rbx
cmpl $0x1, (%rsi)
jne 0x5410a
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x43fe4
jmp 0x54123
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4042a
movq %rbx, %rax
popq %rbx
retq
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::MultipleReporters::testRunStarting(Catch::TestRunInfo const&) | Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{} | pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x54256
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x30(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x54241
popq %rbx
popq %r14
popq %r15
retq
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::MultipleReporters::testGroupStarting(Catch::GroupInfo const&) | Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{} | pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x54286
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x54271
popq %rbx
popq %r14
popq %r15
retq
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::MultipleReporters::testCaseStarting(Catch::TestCaseInfo const&) | Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{} | pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x542b6
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x40(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x542a1
popq %rbx
popq %r14
popq %r15
retq
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::MultipleReporters::sectionStarting(Catch::SectionInfo const&) | Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{} | pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x542e6
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x48(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x542d1
popq %rbx
popq %r14
popq %r15
retq
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::MultipleReporters::assertionStarting(Catch::AssertionInfo const&) | Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{} | pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x54316
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x54301
popq %rbx
popq %r14
popq %r15
retq
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::MultipleReporters::assertionEnded(Catch::AssertionStats const&) | Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r12
cmpq %r12, %r15
je 0x5434f
movq %rsi, %r14
xorl %ebx, %ebx
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x58(%rax)
orb %al, %bl
addq $0x8, %r15
cmpq %r12, %r15
jne 0x54336
jmp 0x54351
xorl %ebx, %ebx
andb $0... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::MultipleReporters::sectionEnded(Catch::SectionStats const&) | Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{} | pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x5438c
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x60(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x54377
popq %rbx
popq %r14
popq %r15
retq
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::MultipleReporters::testCaseEnded(Catch::TestCaseStats const&) | Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{} | pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x543bc
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x68(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x543a7
popq %rbx
popq %r14
popq %r15
retq
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::MultipleReporters::testGroupEnded(Catch::TestGroupStats const&) | Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{} | pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x543ec
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x70(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x543d7
popq %rbx
popq %r14
popq %r15
retq
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::MultipleReporters::testRunEnded(Catch::TestRunStats const&) | Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{} | pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x5441c
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x78(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x54407
popq %rbx
popq %r14
popq %r15
retq
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::MultipleReporters::skipTest(Catch::TestCaseInfo const&) | Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{} | pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x5444f
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x80(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x54437
popq %rbx
popq %r14
popq %r15
retq
nop
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::Option<Catch::TestCaseInfo>::reset() | void reset() {
if( nullableValue )
nullableValue->~T();
nullableValue = CATCH_NULL;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x5477b
movq 0xe0(%r14), %rdi
leaq 0xf0(%r14), %rax
cmpq %rax, %rdi
je 0x54719
callq 0x2d360
movq 0xc0(%r14), %rdi
leaq 0xd0(%r14), %rax
cmpq %rax, %rdi
je 0x54731
callq 0x2d360
leaq 0x90(%r14), %rdi
callq 0x5242a
leaq 0x60(%r14), %r... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::XmlWriter::endElement() | XmlWriter& endElement() {
newlineIfNecessary();
m_indent = m_indent.substr( 0, m_indent.size()-2 );
if( m_tagIsOpen ) {
stream() << "/>\n";
m_tagIsOpen = false;
}
else {
stream() << m_indent << "</" << m_tags.bac... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x1(%rdi)
jne 0x547b5
movq 0x40(%rbx), %rdi
leaq 0x159f8(%rip), %rsi # 0x6a19f
movl $0x1, %edx
callq 0x2d420
movb $0x0, 0x1(%rbx)
leaq 0x20(%rbx), %r14
movq 0x28(%rbx), %rcx
addq $-0x2, %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
... | /dillonhuff[P]bsim/test/catch.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.