name string | code string | asm string | file string |
|---|---|---|---|
Catch::list(Catch::IEventListener&, Catch::Config const&) | bool list( IEventListener& reporter, Config const& config ) {
bool listed = false;
if (config.listTests()) {
listed = true;
listTests(reporter, config);
}
if (config.listTags()) {
listed = true;
listTags(reporter, config);
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r13
movq %rdi, %r12
movb 0x8(%rsi), %bl
cmpb $0x1, %bl
jne 0x362f7
movq (%r13), %rax
movq %r13, %rdi
callq *0x68(%rax)
movq %rax, %r14
movq %r13, %rdi
callq 0x3f49b
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
movq %... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::TestGroup::~TestGroup() | explicit TestGroup(IEventListenerPtr&& reporter, Config const* config):
m_reporter(reporter.get()),
m_config{config},
m_context{config, CATCH_MOVE(reporter)} {
assert( m_config->testSpec().getInvalidSpecs().empty() &&
"Invalid test... | pushq %rbx
movq %rdi, %rbx
addq $0x208, %rdi # imm = 0x208
callq 0x51414
leaq 0x1d8(%rbx), %rdi
callq 0x5678a
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x3c77c
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::RegistrarForTagAliases::RegistrarForTagAliases(char const*, char const*, Catch::SourceLineInfo const&) | RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
CATCH_TRY {
getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
callq 0x4db2c
movq %rax, %r14
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r12, %rsi
callq 0x161da
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
movq %r15, %rsi
callq 0x161da
addq $0x8, %r14
movq (%r14), %rax
le... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Detail::CaseInsensitiveLess::operator()(Catch::StringRef, Catch::StringRef) const | bool CaseInsensitiveLess::operator()( StringRef lhs,
StringRef rhs ) const {
return std::lexicographical_compare(
lhs.begin(), lhs.end(),
rhs.begin(), rhs.end(),
[]( char l, char r ) { return toLower( l ) < toLower... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
cmpq %rdx, %r8
movq %rdx, %r13
cmovlq %r8, %r13
testq %r13, %r13
je 0x36859
movq %r12, %rdi
movq %r15, %rsi
callq 0x4df38
movl %eax, %ebp
testb %al, %al
jne 0x36860
movq %r15, %rdi... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Detail::CaseInsensitiveEqualTo::operator()(Catch::StringRef, Catch::StringRef) const | bool
CaseInsensitiveEqualTo::operator()( StringRef lhs,
StringRef rhs ) const {
return std::equal(
lhs.begin(), lhs.end(),
rhs.begin(), rhs.end(),
[]( char l, char r ) { return toLower( l ) == toLower( r ); }... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
cmpq %r8, %rdx
jne 0x368d5
movq %rdx, %r14
movq %rsi, %r15
xorl %ebx, %ebx
cmpq %rbx, %r14
sete %bpl
je 0x368d7
movsbl (%r15,%rbx), %edi
movq (%rsp), %rax
movsbl (%rax,%rbx), %r12d
callq 0x3eaf4
movl %eax, %r13d
movl %r12d, %... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TestCaseInfo::TestCaseInfo(Catch::StringRef, Catch::NameAndTags const&, Catch::SourceLineInfo const&) | TestCaseInfo::TestCaseInfo(StringRef _className,
NameAndTags const& _nameAndTags,
SourceLineInfo const& _lineInfo):
name( _nameAndTags.name.empty() ? makeDefaultName() : _nameAndTags.name ),
className( _className ),
lineInfo( _lineInf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq 0x8(%rcx), %rbx
testq %rbx, %rbx
movq %rcx, 0x18(%rsp)
je 0x36949
movq %rcx, %rbp
movups (%rcx), %xmm0
movaps %xmm0, (%rsp)
jmp 0x36993
movq 0x72800(%rip), %rsi # 0x... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TestCaseInfo::internalAppendTag(Catch::StringRef) | void TestCaseInfo::internalAppendTag(StringRef tagStr) {
backingTags += '[';
const auto backingStart = backingTags.size();
backingTags += tagStr;
const auto backingEnd = backingTags.size();
backingTags += ']';
tags.emplace_back(StringRef(backingTags.c_str() + backingStart... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rdi), %r12
pushq $0x5b
popq %rsi
movq %r12, %rdi
callq 0x15580
movq 0x38(%rbx), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x150d0
movq 0x38(%rbx), %r14
pushq $0x5d
popq %rs... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TestCaseInfo::addFilenameTag() | void TestCaseInfo::addFilenameTag() {
std::string combined("#");
combined += extractFilenamePart(lineInfo.file);
internalAppendTag(combined);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x34e01(%rip), %rsi # 0x6bd34
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x161da
movq 0x68(%rbx), %r15
movq %r15, %rdi
callq 0x152a0
movq %r15, %rdi
movq %rax, %rsi
callq 0x36fa2
movq %r14, %rdi
movq %rax, %rsi
callq 0x150d... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::extractFilenamePart(Catch::StringRef) | StringRef extractFilenamePart(StringRef filename) {
size_t lastDot = filename.size();
while (lastDot > 0 && filename[lastDot - 1] != '.') {
--lastDot;
}
// In theory we could have filename without any extension in it
if ( lastDot == 0 ) { retur... | addq %rsi, %rdi
xorl %edx, %edx
leaq 0x35e33(%rip), %rax # 0x6cde1
xorl %ecx, %ecx
movq %rsi, %r8
addq %rcx, %r8
je 0x37017
leaq -0x1(%rcx), %r9
cmpb $0x2e, -0x1(%rdi,%rcx)
movq %r9, %rcx
jne 0x36fb0
addq %r9, %rdi
negq %r9
xorl %edx, %edx
movq %rdi, %r8
movq %r9, %rax
movq %rdx, %rcx
movq %rsi, %r10
subq %r9, %r10... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TestCaseInfo::tagsAsString[abi:cxx11]() const | std::string TestCaseInfo::tagsAsString() const {
std::string ret;
// '[' and ']' per tag
std::size_t full_size = 2 * tags.size();
for (const auto& tag : tags) {
full_size += tag.original.size();
}
ret.reserve(full_size);
for (const auto& tag : tags) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x50(%rsi), %rax
movq 0x58(%rsi), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
cmpq %rcx, %rax
je 0x37057
addq 0x8(%rax), %rsi
addq $0x10... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::operator<(Catch::TestCaseInfo const&, Catch::TestCaseInfo const&) | bool operator<( TestCaseInfo const& lhs, TestCaseInfo const& rhs ) {
// We want to avoid redoing the string comparisons multiple times,
// so we store the result of a three-way comparison before using
// it in the actual comparison logic.
const auto cmpName = lhs.name.compare( rhs.name )... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x15050
testl %eax, %eax
jne 0x370e6
leaq 0x20(%r14), %rdi
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0x3710c
testl %eax, %eax
je 0x370f1
shrl $0x1f, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x50, %r14
addq $0x50, %rbx
movq %r14, %... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::StringRef::compare(Catch::StringRef) const | int StringRef::compare( StringRef rhs ) const {
auto cmpResult =
strncmp( m_start, rhs.m_start, std::min( m_size, rhs.m_size ) );
// This means that strncmp found a difference before the strings
// ended, and we can return it directly
if ( cmpResult != 0 ) {
retu... | pushq %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorl %edi, %edi
cmpq %rdx, %rcx
seta %dil
cmovbq %rcx, %rdx
pushq $-0x1
popq %rbx
cmovael %edi, %ebx
movq %rax, %rdi
callq 0x152f0
testl %eax, %eax
cmovel %ebx, %eax
popq %rbx
retq
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::WildcardPattern::matches(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool WildcardPattern::matches( std::string const& str ) const {
switch( m_wildcard ) {
case NoWildcard:
return m_pattern == normaliseString( str );
case WildcardAtStart:
return endsWith( normaliseString( str ), m_pattern );
case WildcardAtEnd:
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl 0x4(%rdi), %eax
cmpq $0x3, %rax
ja 0x372c2
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x326ed(%rip), %rcx # 0x6990c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rbx), %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4104c
movq %r14, %rd... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TestSpec::TagPattern::matches(Catch::TestCaseInfo const&) const | bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
return std::find( begin( testCase.tags ),
end( testCase.tags ),
Tag( m_tag ) ) != end( testCase.tags );
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x50(%rsi), %rax
movq 0x58(%rsi), %rsi
movups 0x28(%rdi), %xmm0
movq %rsp, %rdx
movups %xmm0, (%rdx)
movq %rax, %rdi
callq 0x5ba6d
cmpq 0x58(%rbx), %rax
setne %al
addq $0x10, %rsp
popq %rbx
retq
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TestSpec::Filter::matches(Catch::TestCaseInfo const&) const | bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
bool should_use = !testCase.isHidden();
for (auto const& pattern : m_required) {
should_use = true;
if (!pattern->matches(testCase)) {
return false;
}
}
for (auto co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
testb $0x2, 0x78(%rsi)
movq %rdi, %r14
sete %bpl
movq (%rdi), %r15
movq 0x8(%rdi), %r12
cmpq %r12, %r15
je 0x37449
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
addq $0x8, %r15
movb $0x1, %bpl
testb %al, %al
jne 0x3742b
jmp 0... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TestSpec::Filter::serializeTo(std::ostream&) const | void TestSpec::Filter::serializeTo( std::ostream& out ) const {
bool first = true;
for ( auto const& pattern : m_required ) {
if ( !first ) {
out << ' ';
}
out << *pattern;
first = false;
}
for ( auto const& pattern : m_forb... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %r12
movb $0x1, %al
pushq $0x20
popq %rbp
cmpq %r12, %r15
je 0x374bd
testb $0x1, %al
jne 0x374a9
movq %rbx, %rdi
movl %ebp, %esi
callq 0x15770
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
call... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TestSpec::matches(Catch::TestCaseInfo const&) const | bool TestSpec::matches( TestCaseInfo const& testCase ) const {
return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %rbx
movq 0x8(%rdi), %rbp
movq %rbp, %r15
subq %rbx, %r15
pushq $0x30
popq %rcx
movq %r15, %rax
cqto
idivq %rcx
movq %rax, %r12
sarq $0x2, %r12
testq %r12, %r12
jle 0x37600
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TestSpec::matchesByFilter(std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>> const&, Catch::IConfig const&) const | TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const {
Matches matches;
matches.reserve( m_filters.size() );
for ( auto const& filter : m_filters ) {
std::vector<TestCaseHandle const*> currentMatches;
for... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r14
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
pushq $0x30
popq %rcx
cqto
idivq %rcx
movq %rdi, 0x8(%rsp)
movq %rax, %rsi
callq 0... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TestSpec::serializeTo(std::ostream&) const | void TestSpec::serializeTo( std::ostream& out ) const {
bool first = true;
for ( auto const& filter : m_filters ) {
if ( !first ) {
out << ',';
}
out << filter;
first = false;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
movb $0x1, %al
pushq $0x2c
popq %rbp
cmpq %r15, %r14
je 0x3780e
testb $0x1, %al
jne 0x377fb
movq %rbx, %rdi
movl %ebp, %esi
callq 0x15770
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3747c
addq $0x30, %r14
xorl %eax... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Detail::convertIntoString[abi:cxx11](Catch::StringRef, bool) | std::string convertIntoString(StringRef string, bool escapeInvisibles) {
std::string ret;
// This is enough for the "don't escape invisibles" case, and a good
// lower bound on the "escape invisibles" case.
ret.reserve(string.size() + 2);
if (!escapeInvisibles) {
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r14
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
leaq 0x2(%rdx), %rsi
callq 0x15950
testb %bpl, %bpl
je 0x378f6
pushq $0x22
popq %rsi
movq %rbx, ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
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;
}
uns... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3c508
movq 0x8(%r15), %r15
leaq 0x33ff7(%rip), %rsi # 0x6b99a
movq %r15, %rdi
callq 0x15630
pushq $0x30
popq %rsi
movq %r15, %rdi
callq 0x15960
movq (%r15), %rax
... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::StringMaker<char*, void>::convert[abi:cxx11](char*) | std::string StringMaker<char*>::convert(char* str) { // NOLINT(readability-non-const-parameter)
if (str) {
return Detail::convertIntoString( str );
} else {
return{ "{null string}" };
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x37adb
movq %rsi, %r14
movq %rsi, %rdi
callq 0x152a0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x37941
jmp 0x37aef
leaq 0x33ea8(%rip), %rsi # 0x6b98a
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x161da
movq %rbx, %rax
addq $0x8, %rsp
p... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::StringMaker<wchar_t const*, void>::convert[abi:cxx11](wchar_t const*) | std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
if (str) {
return ::Catch::Detail::stringify(std::wstring{ str });
} else {
return{ "{null string}" };
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x37c3e
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x51462
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37afa
leaq 0x8(%rsp), %rdi
callq 0x150e0
jmp 0x37c52
leaq 0x33d45(%rip), %rsi # 0x6b98a
leaq 0x8(%rsp), %rdx
movq %rbx, %... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::StringMaker<wchar_t*, void>::convert[abi:cxx11](wchar_t*) | std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
if (str) {
return ::Catch::Detail::stringify(std::wstring{ str });
} else {
return{ "{null string}" };
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x37caa
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x51462
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37afa
leaq 0x8(%rsp), %rdi
callq 0x150e0
jmp 0x37cbe
leaq 0x33cd9(%rip), %rsi # 0x6b98a
leaq 0x8(%rsp), %rdx
movq %rbx, %... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::StringMaker<long long, void>::convert[abi:cxx11](long long) | std::string StringMaker<long long>::convert(long long value) {
ReusableStringStream rss;
rss << value;
if (value > Detail::hexThreshold) {
rss << " (0x" << std::hex << value << ')';
}
return rss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3c508
movq 0x8(%r14), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x15200
cmpq $0x100, %r15 # imm = 0x100
jl 0x37d7c
leaq 0x33c51(%rip), %rsi # 0x6b998
movq %r14, %rdi
callq 0x15630
mo... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::StringMaker<unsigned long long, void>::convert[abi:cxx11](unsigned long long) | std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
ReusableStringStream rss;
rss << value;
if (value > Detail::hexThreshold) {
rss << " (0x" << std::hex << value << ')';
}
return rss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3c508
movq 0x8(%r14), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x15430
cmpq $0x100, %r15 # imm = 0x100
jb 0x37e42
leaq 0x33b8b(%rip), %rsi # 0x6b998
movq %r14, %rdi
callq 0x15630
mo... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::StringMaker<signed char, void>::convert[abi:cxx11](signed char) | std::string StringMaker<signed char>::convert(signed char value) {
if (value == '\r') {
return "'\\r'";
} else if (value == '\f') {
return "'\\f'";
} else if (value == '\n') {
return "'\\n'";
} else if (value == '\t') {
return "'\\t'";
} else if ('\0' <= value && valu... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leal -0x9(%rsi), %eax
cmpl $0x4, %eax
ja 0x37ee3
leaq 0x31a89(%rip), %rcx # 0x6991c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x33b09(%rip), %rsi # 0x6b9ac
leaq 0x8(%rsp), %rdx
jmp 0x37ed2
leaq 0x33af1(%rip), %rsi # 0x6b9a2
leaq 0xa(%rsp), %rdx
jm... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::StringMaker<float, void>::convert[abi:cxx11](float) | std::string StringMaker<float>::convert(float value) {
return Detail::fpToString(value, precision) + 'f';
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movss %xmm0, 0xc(%rsp)
ucomiss %xmm0, %xmm0
jp 0x38038
movslq 0x70afc(%rip), %r15 # 0xa8a50
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x3c508
movq 0x8(%r14), %r14
movq (%r14), %rax
movq -0x18(%rax), %rcx
movq %r15, 0x8(%r14,%rcx)
movq -0x18(%rax), ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::StringMaker<double, void>::convert[abi:cxx11](double) | std::string StringMaker<double>::convert(double value) {
return Detail::fpToString(value, precision);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
ucomisd %xmm0, %xmm0
jp 0x3816a
movslq 0x709ab(%rip), %r15 # 0xa8a54
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3c508
movq 0x8(%r14), %r14
movq (%r14), %rax
movq -0x18(%rax), %rcx
movq %r15, 0x8(%r14,%rcx)
movq -0x18(%rax), ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Counts::operator-(Catch::Counts const&) const | Counts Counts::operator - ( Counts const& other ) const {
Counts diff;
diff.passed = passed - other.passed;
diff.failed = failed - other.failed;
diff.failedButOk = failedButOk - other.failedButOk;
diff.skipped = skipped - other.skipped;
return diff;
} | movq %rdi, %rax
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)
retq
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Totals::delta(Catch::Totals const&) const | Totals 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 if ( diff.assertions.skipped > 0 )
... | pushq %rbx
movq %rdi, %rbx
callq 0x38214
cmpq $0x0, 0x8(%rbx)
je 0x38288
pushq $0x28
jmp 0x38291
cmpq $0x0, 0x10(%rbx)
je 0x3829b
pushq $0x30
popq %rax
incq (%rbx,%rax)
movq %rbx, %rax
popq %rbx
retq
cmpq $0x0, 0x18(%rbx)
pushq $0x20
popq %rcx
pushq $0x38
popq %rax
cmoveq %rcx, %rax
jmp 0x38292
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::SimplePcg32::operator()() | SimplePcg32::result_type SimplePcg32::operator()() {
// prepare the output value
const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
const auto output = rotate_right(xorshifted, m_state >> 59u);
// advance state
m_state = m_state * 63641362238... | movq (%rdi), %rax
movq %rax, %rdx
movq %rax, %rcx
movabsq $0x5851f42d4c957f2d, %rsi # imm = 0x5851F42D4C957F2D
imulq %rax, %rsi
shrq $0x2d, %rax
shrq $0x1b, %rdx
xorl %edx, %eax
shrq $0x3b, %rcx
rorl %cl, %eax
movabsq $0x27da198a7f2728ed, %rcx # imm = 0x27DA198A7F2728ED
addq %rsi, %rcx
movq %rcx, (%rdi)
retq
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Generators::RandomFloatingGenerator<long double>::RandomFloatingGenerator(long double, long double, unsigned int) | RandomFloatingGenerator<long double>::RandomFloatingGenerator(
long double a, long double b, std::uint32_t seed) :
m_pimpl(Catch::Detail::make_unique<PImpl>(a, b, seed)) {
static_cast<void>( next() );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
fldt 0x60(%rsp)
fldt 0x50(%rsp)
fstpt 0x20(%rsp)
fstpt 0x10(%rsp)
leaq 0xc(%rsp), %rcx
movl %esi, (%rcx)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x6bfc0(%rip), %rax # 0xa4428
m... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Generators::GeneratorUntypedBase::countedNext() | bool GeneratorUntypedBase::countedNext() {
auto ret = next();
if ( ret ) {
m_stringReprCache.clear();
++m_currentElementIndex;
}
return ret;
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
je 0x38523
andq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rcx
movb $0x0, (%rcx)
incq 0x28(%rbx)
popq %rbx
retq
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Generators::GeneratorUntypedBase::currentElementAsString() const | StringRef GeneratorUntypedBase::currentElementAsString() const {
if ( m_stringReprCache.empty() ) {
m_stringReprCache = stringifyImpl();
}
return m_stringReprCache;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rdi), %rbx
movq 0x10(%rdi), %rdx
testq %rdx, %rdx
jne 0x38565
movq %rdi, %r14
movq (%rdi), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x157c0
movq %r15, %rdi
callq 0x15c18
movq 0x10(%r14), %rdx
m... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::AssertionStats::AssertionStats(Catch::AssertionResult const&, std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>> const&, Catch::Totals const&) | AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
std::vector<MessageInfo> const& _infoMessages,
Totals const& _totals )
: assertionResult( _assertionResult ),
infoMessages( _infoMessages ),
totals( _tot... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
callq 0x51544
leaq 0x90(%rbx), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x51570
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups 0x30(%r15), %xmm3
movups %xmm3, 0xd8(%rbx)
movups %... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::AssertionHandler::complete() | void AssertionHandler::complete() {
m_completed = true;
if( m_reaction.shouldDebugBreak ) {
// If you find your debugger stopping you here then go one level up on the
// call-stack for the code that caused it (typically a failed assertion)
// (To go back to the test... | pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x3b(%rdi)
cmpb $0x1, 0x38(%rdi)
jne 0x3885a
callq 0x3a87e
testb %al, %al
je 0x3885a
int3
cmpb $0x1, 0x39(%rbx)
je 0x38868
cmpb $0x1, 0x3a(%rbx)
je 0x3886d
popq %rbx
retq
callq 0x38872
callq 0x3888c
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::handleExceptionMatchExpr(Catch::AssertionHandler&, Catch::Matchers::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) | void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher ) {
std::string exceptionMessage = Catch::translateActiveException();
MatchExpr<std::string, StringMatcher const&> expr( CATCH_MOVE(exceptionMessage), matcher );
handler.handleExpr( expr );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x32b2c
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x18(%rax)
leaq 0x20(%rsp), %rdx
movb $0x1, 0x8(%rdx)
movb %al, 0x9(%rdx)
leaq 0x6f31b(%rip), %rax # 0xa7d00
movq %rax, (%rdx)
movq... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Detail::TokenStream::operator++() | TokenStream& TokenStream::operator++() {
if ( m_tokenBuffer.size() >= 2 ) {
m_tokenBuffer.erase( m_tokenBuffer.begin() );
} else {
if ( it != itEnd )
++it;
loadBuffer();
}
... | pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rax
subq %rsi, %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
cmpq $0x2, %rax
jb 0x38c42
leaq 0x10(%rbx), %rdi
callq 0x51660
jmp 0x38c5a
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x38c52
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x38a74
movq ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Detail::convertInto(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>>&) | ParserResult convertInto( std::string const& source,
std::string& target ) {
target = source;
return ParserResult::ok( ParseResultType::Matched );
} | pushq %rbx
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x15360
andq $0x0, 0x8(%rbx)
leaq 0x6e8e9(%rip), %rax # 0xa7560
movq %rax, (%rbx)
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Detail::convertInto(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool&) | ParserResult convertInto( std::string const& source,
bool& target ) {
std::string srcLC = toLower( source );
if ( srcLC == "y" || srcLC == "1" || srcLC == "true" ||
srcLC == "yes" || srcLC == "on" ) {
target ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x371db
leaq 0x3284c(%rip), %rsi # 0x6b503
movq %r12, %rdi
callq 0x20b33
movb $0x1, %bpl
testb %al, %al
jne 0x38d7f
leaq 0x3001a(%rip), %rsi # 0x68ceb
mov... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Detail::BoundFlagRef::setFlag(bool) | ParserResult BoundFlagRef::setFlag( bool flag ) {
m_ref = flag;
return ParserResult::ok( ParseResultType::Matched );
} | movq %rdi, %rax
movq 0x8(%rsi), %rcx
movb %dl, (%rcx)
andq $0x0, 0x8(%rdi)
leaq 0x6e6ed(%rip), %rcx # 0xa7560
movq %rcx, (%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
retq
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Arg::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Clara::Detail::TokenStream) const | Detail::InternalParseResult Arg::parse(std::string const&,
Detail::TokenStream tokens) const {
auto validationResult = validate();
if (!validationResult)
return Detail::InternalParseResult(validationResult);
auto token =... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x80(%rsp), %r12
movq %r12, %rdi
callq *0x10(%rax)
cmpl $0x0, 0x8(%r12)
je 0x38edd
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x516ae
jmp 0x3902f
leaq... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Opt::Opt(bool&) | Opt::Opt(bool& ref) :
ParserRefImpl(std::make_shared<Detail::BoundFlagRef>(ref)) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x51779
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r15
movaps -0x8(%r15), %xmm0
movaps %xmm0, -0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r15)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x51798
movq %r14, %rdi
callq 0x16ca2
movq ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Opt::getHelpColumns() const | Detail::HelpColumns Opt::getHelpColumns() const {
ReusableStringStream oss;
bool first = true;
for (auto const& opt : m_optNames) {
if (first)
first = false;
else
oss << ", ";
oss << opt;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3c508
movq 0x40(%r14), %r12
movq 0x48(%r14), %rbp
movb $0x1, %al
leaq 0x32899(%rip), %r13 # 0x6b9ed
cmpq %rbp, %r12
je 0x3917d
testb $0x1, %al
jne 0x3916a
m... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
(anonymous namespace)::normaliseOpt(Catch::StringRef) | Catch::StringRef normaliseOpt( Catch::StringRef optName ) {
if ( optName[0] == '-'
#if defined(CATCH_PLATFORM_WINDOWS)
|| optName[0] == '/'
#endif
) {
return optName.substr( 1, optName.size() );
}
return optName;
} | movq %rsi, %rdx
movq %rdi, %rax
cmpb $0x2d, (%rdi)
jne 0x392a7
leaq -0x1(%rdx), %rcx
incq %rax
cmpq %rdx, %rcx
cmovaeq %rdx, %rcx
xorl %esi, %esi
cmpq $0x2, %rdx
leaq 0x33b45(%rip), %rdx # 0x6cde1
cmovbq %rdx, %rax
cmovaeq %rcx, %rsi
movq %rsi, %rdx
retq
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Opt::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Clara::Detail::TokenStream) const | Detail::InternalParseResult Opt::parse(std::string const&,
Detail::TokenStream tokens) const {
auto validationResult = validate();
if (!validationResult)
return Detail::InternalParseResult(validationResult);
if (tokens &&
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rcx, %r14
movq %rsi, %r13
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x80(%rsp), %r15
movq %r15, %rdi
callq *0x10(%rax)
cmpl $0x0, 0x8(%r15)
je 0x392ef
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x516ae
jmp 0... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::operator+[abi:cxx11](Catch::StringRef, Catch::StringRef) | std::string operator+(StringRef lhs, StringRef rhs) {
std::string ret;
ret.reserve(lhs.size() + rhs.size());
ret += lhs;
ret += rhs;
return ret;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r12
movq %rsi, %r13
movb $0x0, 0x10(%rdi)
leaq (%r8,%rdx), %rsi
callq 0x15950
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x150d0
movq ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Opt::validate() const | Detail::Result Opt::validate() const {
if (m_optNames.empty())
return Detail::Result::logicError("No options supplied to Opt");
for (auto const& name : m_optNames) {
if (name.empty())
return Detail::Result::logicError(
"... | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x40(%rsi), %rax
movq 0x48(%rsi), %rcx
cmpq %rcx, %rax
je 0x39794
cmpq %rcx, %rax
je 0x397b9
cmpq $0x0, 0x8(%rax)
je 0x397da
movq (%rax), %rdx
addq $0x10, %rax
cmpb $0x2d, (%rdx)
je 0x39757
leaq 0x322d1(%rip), %rsi # 0x6ba47
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::ExeName::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Clara::Detail::TokenStream) const | Detail::InternalParseResult
ExeName::parse(std::string const&,
Detail::TokenStream tokens) const {
return Detail::InternalParseResult::ok(
Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens)));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
movups (%rcx), %xmm0
leaq 0x40(%rsp), %rbx
movaps %xmm0, -0x10(%rbx)
movq 0x20(%rcx), %rax
leaq 0x18(%rsp), %r15
movups 0x10(%rcx), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rcx)
andq $0x0, 0x20(%rcx)
movl $0x1, -0x18(%r15)
movups (%rcx), %xmm2
movups... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Parser::operator|=(Catch::Clara::Parser const&) | Parser& Parser::operator|=( Parser const& other ) {
m_options.insert( m_options.end(),
other.m_options.begin(),
other.m_options.end() );
m_args.insert(
m_args.end(), other.m_args.begin(), other.m_args.end() );
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x30, %rdi
movq 0x38(%r14), %rsi
movq 0x30(%rbx), %rdx
movq 0x38(%rbx), %rcx
callq 0x51872
leaq 0x48(%r14), %rdi
movq 0x50(%r14), %rsi
movq 0x48(%rbx), %rdx
movq 0x50(%rbx), %rcx
callq 0x51892
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Parser::writeToStream(std::ostream&) const | void Parser::writeToStream( std::ostream& os ) const {
if ( !m_exeName.name().empty() ) {
os << "usage:\n"
<< " " << m_exeName.name() << ' ';
bool required = true, first = true;
for ( auto const& arg : m_args ) {
if ( fi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdi, %r14
movq 0x10(%rdi), %rax
cmpq $0x0, 0x8(%rax)
movq %rsi, (%rsp)
je 0x39c0f
movq %rsi, %rcx
leaq 0x31f70(%rip), %rsi # 0x6ba77
movq %rcx, %rdi
callq 0x15630
leaq 0x3340b(%rip), %rsi # 0x6cf21... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Parser::validate() const | Detail::Result Parser::validate() const {
for ( auto const& opt : m_options ) {
auto result = opt.validate();
if ( !result )
return result;
}
for ( auto const& arg : m_args ) {
auto result = arg.validate();
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsi), %r15
movq 0x38(%rsi), %r12
cmpq %r12, %r15
je 0x3a009
movq (%r15), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x10(%rax)
cmpl $0x0, 0x8(%rbx)
jne 0x3a055
movq %rbx, %rdi
callq 0x51766
addq $0x58, %r15
jmp 0x39fe4
mo... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Clara::Detail::TokenStream) const | Detail::InternalParseResult
Parser::parse( std::string const& exeName,
Detail::TokenStream tokens ) const {
struct ParserInfo {
ParserBase const* parser = nullptr;
size_t count = 0;
};
std::vector<ParserInfo> parseInfos;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rcx, %r15
movq %rdx, 0x30(%rsp)
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq 0x30(%rsi), %rbx
movq 0x38(%rsi), %r14
movq %r14, %rax
subq %rbx, %rax
pushq $0x5... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Help::Help(bool&) | Help::Help( bool& showHelpFlag ):
Opt( [&]( bool flag ) {
showHelpFlag = flag;
return ParserResult::ok( ParseResultType::ShortCircuitAll );
} ) {
static_cast<Opt&> ( *this )(
"display usage information" )["-?"]["-h"]["--help"]
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
pushq $0x20
popq %rdi
callq 0x15640
movq %rax, %r12
leaq 0x7(%rsp), %rax
leaq 0x8(%rsp), %r13
movq %rax, (%r13)
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r12... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::ColourImpl::ColourGuard::operator=(Catch::ColourImpl::ColourGuard&&) | ColourImpl::ColourGuard&
ColourImpl::ColourGuard::operator=( ColourGuard&& rhs ) noexcept {
using std::swap;
swap( m_colourImpl, rhs.m_colourImpl );
swap( m_code, rhs.m_code );
swap( m_engaged, rhs.m_engaged );
return *this;
} | movq %rdi, %rax
movq (%rdi), %rcx
movq (%rsi), %rdx
movq %rdx, (%rdi)
movq %rcx, (%rsi)
movl 0x8(%rdi), %ecx
movl 0x8(%rsi), %edx
movl %edx, 0x8(%rdi)
movl %ecx, 0x8(%rsi)
movb 0xc(%rdi), %cl
movb 0xc(%rsi), %dl
movb %dl, 0xc(%rdi)
movb %cl, 0xc(%rsi)
retq
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::isDebuggerActive() | ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
callq 0x15070
movq %rax, %rbx
movl (%rax), %ebp
leaq 0x31a48(%rip), %rsi # 0x6c2e8
leaq 0x20(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x15b00
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Detail::makeEnumInfo(Catch::StringRef, Catch::StringRef, std::vector<int, std::allocator<int>> const&) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
auto enumInfo = Catch::Detail::make_unique<EnumInfo>();
enumInfo->m_name = enumName;
enumInfo->m_values.reserve( values.size() );
const auto ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x51e03
movq (%rbx), %rax
movq %rbp, (%rax)
movq %r13, 0x8(%rax)
movq (%rbx), %rdi
addq $0x10, %rdi
movq 0x8(%r14), %rsi
subq (%r14), %rs... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JsonValueWriter::writeImpl(Catch::StringRef, bool) | void JsonValueWriter::writeImpl( Catch::StringRef value, bool quote ) {
if ( quote ) { m_os << '"'; }
for (char c : value) {
// Escape list taken from https://www.json.org/json-en.html,
// string definition.
// Note that while forward slash _can_ be escaped, it does
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %ecx, 0x4(%rsp)
testl %ecx, %ecx
je 0x3b629
movq (%rbx), %rdi
pushq $0x22
popq %rsi
callq 0x15770
xorl %r12d, %r12d
leaq 0x2e2fd(%rip), %r13 # 0x69930
leaq 0x30344(%rip), %rbp # 0x6b... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::operator<<(std::ostream&, Catch::LazyExpression const&) | auto operator << (std::ostream& os, LazyExpression const& lazyExpr) -> std::ostream& {
if (lazyExpr.m_isNegated)
os << '!';
if (lazyExpr) {
if (lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression())
os << '(' << *lazyExpr.m_transientExpress... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x8(%rsi)
jne 0x3b722
pushq $0x21
popq %rsi
movq %rbx, %rdi
callq 0x15770
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3b767
cmpb $0x1, 0x8(%r14)
jne 0x3b75d
cmpb $0x1, 0x8(%rdi)
jne 0x3b75d
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x15770
movq %... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TagInfo::all[abi:cxx11]() const | std::string TagInfo::all() const {
// 2 per tag for brackets '[' and ']'
size_t size = spellings.size() * 2;
for (auto const& spelling : spellings) {
size += spelling.size();
}
std::string out; out.reserve(size);
for (auto const& spelling : spellings) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rax
movq 0x28(%rsi), %r15
addq %r15, %r15
leaq 0x8(%rsi), %r12
cmpq %r12, %rax
je 0x3b7e4
addq 0x28(%rax), %r15
movq %rax, %rdi
callq 0x15750
jmp 0x3b7d1
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::RedirectedStream::RedirectedStream(std::ostream&, std::ostream&) | RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
: m_originalStream( originalStream ),
m_redirectionStream( redirectionStream ),
m_prevBuf( m_originalStream.rdbuf() )
{
m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
} | movq %rsi, %rax
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq (%rsi), %rcx
movq -0x18(%rcx), %rsi
movq 0xe8(%rax,%rsi), %rsi
movq %rsi, 0x10(%rdi)
addq -0x18(%rcx), %rax
movq (%rdx), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%rdx,%rcx), %rsi
movq %rax, %rdi
jmp 0x15b40
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::RedirectedStdErr::RedirectedStdErr() | RedirectedStdErr::RedirectedStdErr()
: m_cerr( Catch::cerr(), m_rss.get() ),
m_clog( Catch::clog(), m_rss.get() )
{} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3c508
leaq 0x10(%rbx), %r14
movq 0x8(%rbx), %rdx
movq 0x6c63c(%rip), %rsi # 0xa7fe8
movq %r14, %rdi
callq 0x3b8ec
leaq 0x28(%rbx), %rdi
movq 0x8(%rbx), %rdx
movq 0x6c575(%rip), %rsi # 0xa7f38
callq 0x3b8ec
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r1... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::RedirectedStreams::~RedirectedStreams() | RedirectedStreams::~RedirectedStreams() {
m_redirectedCout += m_redirectedStdOut.str();
m_redirectedCerr += m_redirectedStdErr.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x30f28
movq (%r14), %rdi
movq %rsp, %rsi
callq 0x15b90
movq %rsp, %rdi
callq 0x15c18
leaq 0x38(%r14), %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x30f28
movq 0x8(%r14), %rdi
movq %rsp, %rsi
cal... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::parseUInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | Optional<unsigned int> parseUInt(std::string const& input, int base) {
auto trimmed = trim( input );
// std::stoull is annoying and accepts numbers starting with '-',
// it just negates them into unsigned int
if ( trimmed.empty() || trimmed[0] == '-' ) {
return {};
}
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x319c8
cmpq $0x0, 0x8(%r14)
je 0x3bae4
movq 0x10(%rsp), %rax
cmpb $0x2d, (%rax)
jne 0x3baea
andq $0x0, (%rbx)
jmp 0x3bb23
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
movl %ebp,... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::generateRandomSeed(Catch::GenerateFrom) | std::uint32_t generateRandomSeed( GenerateFrom from ) {
switch ( from ) {
case GenerateFrom::Time:
return static_cast<std::uint32_t>( std::time( nullptr ) );
case GenerateFrom::Default:
case GenerateFrom::RandomDevice: {
std::random_device rd;
return ... | pushq %rbx
subq $0x13a0, %rsp # imm = 0x13A0
leal -0x1(%rdi), %eax
cmpl $0x2, %eax
jae 0x3bc29
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x5205a
movq %rbx, %rdi
callq 0x15880
movl %eax, %ebx
leaq 0x18(%rsp), %rdi
callq 0x520b0
jmp 0x3bc37
testl %edi, %edi
jne 0x3bc42
xorl %edi, %edi
callq 0x155d0
movq %rax,... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::ReporterRegistry::ReporterRegistry() | ReporterRegistry::ReporterRegistry():
m_impl( Detail::make_unique<ReporterRegistryImpl>() ) {
// Because it is impossible to move out of initializer list,
// we have to add the elements manually
m_impl->factories["Automake"] =
Detail::make_unique<ReporterFactory<AutomakeRepor... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x520c0
leaq 0x8(%rsp), %rdi
callq 0x520f3
movq (%rbx), %r14
leaq 0x3076e(%rip), %rsi # 0x6c443
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x161da
addq $0x18, %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x52112
movq %rax, %r14
movq 0... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::ReporterRegistry::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::ReporterConfig&&) const | IEventListenerPtr
ReporterRegistry::create( std::string const& name,
ReporterConfig&& config ) const {
auto it = m_impl->factories.find( name );
if ( it == m_impl->factories.end() ) return nullptr;
return it->second->create( CATCH_MOVE( config ) );
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
addq $0x18, %rdi
movq %rdx, %rsi
callq 0x5d3b2
movq (%r15), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
je 0x3c149
movq 0x40(%rax), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
movq %r14, %rdx
callq *0x10(%rax)
jmp 0x3c14d
andq $0x0,... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::ReporterRegistry::registerReporter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Detail::unique_ptr<Catch::IReporterFactory>) | void ReporterRegistry::registerReporter( std::string const& name,
IReporterFactoryPtr factory ) {
CATCH_ENFORCE( name.find( "::" ) == name.npos,
"'::' is not allowed in reporter name: '" + name +
'\'' );
auto ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x2a71a(%rip), %rsi # 0x66889
movq %rbx, %rdi
xorl %edx, %edx
callq 0x15bb0
cmpq $-0x1, %rax
jne 0x3c1a0
movq (%r15), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5f8f6
testb $0x1, %dl
je 0x3c1fb
... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Detail::splitReporterSpec[abi:cxx11](Catch::StringRef) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
static constexpr auto separator = "::";
static constexpr size_t separatorSize = 2;
size_t separatorPos = 0;
auto findNextSeparator = [&reporterSpec]( size_t startPos ) {
static_assert(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
leaq 0x18(%rsp), %r12
movq %rax, %rbp
movq %r13, %rax
subq %rbp, %rax
jbe 0x3c35f
movq %rbp, %rcx
movq %r13, %r... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Detail::stringToColourMode(Catch::StringRef) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
if ( colourMode == "default" ) {
return ColourMode::PlatformDefault;
} else if ( colourMode == "ansi" ) {
return ColourMode::ANSI;
} else if ( colourMode == "win32" ) {
r... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x2fb71(%rip), %rsi # 0x6bf2c
pushq $0x7
popq %rdx
callq 0x517ce
testb %al, %al
je 0x3c3cb
xorl %ecx, %ecx
jmp 0x3c413
leaq 0x30102(%rip), %rsi # 0x6c4d4
movq %rsp, %rdi
pushq $0x4
popq %rdx
callq 0x517ce
mov... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::operator==(Catch::ReporterSpec const&, Catch::ReporterSpec const&) | bool operator==( ReporterSpec const& lhs, ReporterSpec const& rhs ) {
return lhs.m_name == rhs.m_name &&
lhs.m_outputFileName == rhs.m_outputFileName &&
lhs.m_colourMode == rhs.m_colourMode &&
lhs.m_customOptions == rhs.m_customOptions;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1735e
testb %al, %al
je 0x3c479
leaq 0x20(%r14), %rdi
leaq 0x20(%rbx), %rsi
callq 0x522ca
testb %al, %al
je 0x3c479
leaq 0x48(%r14), %rdi
leaq 0x48(%rbx), %rsi
callq 0x522f0
testb %al, %al
je 0x3c479
addq $0x58, %r14
addq $0x58, %rbx
movq %r14, %r... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::ReporterSpec::ReporterSpec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Catch::Optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, Catch::Optional<Catch::ColourMode>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | ReporterSpec::ReporterSpec(
std::string name,
Optional<std::string> outputFileName,
Optional<ColourMode> colourMode,
std::map<std::string, std::string> customOptions ):
m_name( CATCH_MOVE( name ) ),
m_outputFileName( CATCH_MOVE( outputFileName ) ),
m_colourMode( C... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
callq 0x15810
leaq 0x20(%r14), %rdi
movq %r12, %rsi
callq 0x52348
movq (%r15), %rcx
testq %rcx, %rcx
je 0x3c4bd
leaq 0x50(%r14), %rax
movb (%rcx), %cl
movb %cl, 0x50(%r14)
jmp 0x3c4bf
xorl %eax, %eax
mo... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::ReusableStringStream::ReusableStringStream() | ReusableStringStream::ReusableStringStream()
: m_index( Singleton<StringStreams>::getMutable().add() ),
m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
{} | pushq %rbx
movq %rdi, %rbx
callq 0x5fe06
leaq 0x8(%rax), %rdi
callq 0x52392
movq %rax, (%rbx)
callq 0x5fe06
movq (%rbx), %rcx
movq 0x8(%rax), %rax
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rbx)
popq %rbx
retq
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::ReusableStringStream::~ReusableStringStream() | ReusableStringStream::~ReusableStringStream() {
static_cast<std::ostringstream*>( m_oss )->str("");
m_oss->clear();
Singleton<StringStreams>::getMutable().release( m_index );
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
leaq 0x30898(%rip), %rsi # 0x6cde1
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x161da
addq $0x8, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x15930
leaq 0x8(%rsp), %rdi
callq 0x15c18
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
addq -0x... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::RunContext::RunContext(Catch::IConfig const*, Catch::Detail::unique_ptr<Catch::IEventListener>&&) | RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter)
: m_runInfo(_config->name()),
m_config(_config),
m_reporter(CATCH_MOVE(reporter)),
m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
m_includeSuccessfulResul... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x67f8d(%rip), %rax # 0xa4560
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x18(%rax)
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
xorps %xmm0, %xmm0
andq $0x0, 0x28(%rbx)
mo... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::RunContext::~RunContext() | RunContext::~RunContext() {
m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0x108(%rdi), %r14
callq 0x3c84c
movups 0x8(%rbx), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movups 0xc8(%rbx), %xmm0
movups 0xd8(%rbx), %xmm1
movups 0xe8(%rbx), %xmm2
movups 0xf8(%rbx), %xmm3
movaps %xmm0, 0x10(%rsi)
movaps %xmm1, 0x20(%rsi)
movaps %xmm2, 0x3... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::RunContext::runTest(Catch::TestCaseHandle const&) | Totals RunContext::runTest(TestCaseHandle const& testCase) {
const Totals prevTotals = m_totals;
auto const& testInfo = testCase.getTestCaseInfo();
m_reporter->testCaseStarting(testInfo);
m_activeTestCase = &testCase;
ITracker& rootTracker = m_trackerContext.startRun();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
leaq 0xc8(%rsi), %r13
movups 0xc8(%rsi), %xmm0
movups 0xd8(%rsi), %xmm1
movups 0xe8(%rsi), %xmm2
movups 0xf8(%rsi), %xmm3
movaps %xmm3, 0x120(%rsp)
movaps %x... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TestCaseTracking::TrackerContext::startRun() | ITracker& TrackerContext::startRun() {
using namespace std::string_literals;
m_rootTracker = Catch::Detail::make_unique<SectionTracker>(
NameAndLocation( "{root}"s, CATCH_INTERNAL_LINEINFO ),
*this,
nullptr );
m_currentTracker = nullptr;
m_runState = E... | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x2f9a7(%rip), %rsi # 0x6c60c
leaq 0x10(%rsp), %r14
pushq $0x6
popq %rdx
movq %r14, %rdi
callq 0x1673a
leaq 0x48(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%r14), %rdx
leaq 0x20(%rsp), %rax
cmpq %rax, %rdx
je 0x3cc9c
movq %rdx, 0x38(%rsp)
movq 0x20(%rsp), %r... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TextFlow::Column::const_iterator::addIndentAndSuffix[abi:cxx11](Catch::TextFlow::AnsiSkippingString::const_iterator, Catch::TextFlow::AnsiSkippingString::const_iterator) const | std::string Column::const_iterator::addIndentAndSuffix(
AnsiSkippingString::const_iterator start,
AnsiSkippingString::const_iterator end ) const {
std::string ret;
const auto desired_indent = indentSize();
// ret.reserve( desired_indent + (end - start) + m_add... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r15
movq %rcx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x409e8
pushq $0x20
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x156e0
movq (%r14), %r... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TextFlow::Column::const_iterator::const_iterator(Catch::TextFlow::Column const&) | Column::const_iterator::const_iterator( Column const& column ):
m_column( column ),
m_lineStart( column.m_string.begin() ),
m_lineEnd( column.m_string.begin() ),
m_parsedTo( column.m_string.begin() ) {
assert( m_column.m_width > m_column.m_indent );
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rsi, %rdi
callq 0x40704
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %r14, %rdi
callq 0x40704
movq %rax, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
movq %r14, %rdi
callq 0x40704
movq %rax, 0x28(%rbx)
movq %rdx, 0x30(%rbx)
movb $0x0, 0x38(... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TextFlow::Column::const_iterator::operator++() | Column::const_iterator& Column::const_iterator::operator++() {
m_lineStart = m_lineEnd;
AnsiSkippingString const& current_line = m_column.m_string;
if ( m_lineStart != current_line.end() && *m_lineStart == '\n' ) {
m_lineStart++;
} else {
w... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movups 0x18(%rdi), %xmm0
movups %xmm0, 0x8(%rdi)
movq (%rdi), %r15
movq (%r15), %rax
movq 0x8(%r15), %rcx
leaq (%rax,%rcx), %rsi
movq 0x10(%rdi), %rdx
cmpq %rsi, %rdx
je 0x40bb3
cmpb $0xa, (%rdx)
jne 0x40bb3
movq %r14, %rdi
xorl %esi, %esi
callq 0x52... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TextFlow::Columns::iterator::iterator(Catch::TextFlow::Columns const&, Catch::TextFlow::Columns::iterator::EndTag) | Columns::iterator::iterator( Columns const& columns, EndTag ):
m_columns( columns.m_columns ), m_activeIterators( 0 ) {
m_iterators.reserve( m_columns.size() );
for ( auto const& col : m_columns ) {
m_iterators.push_back( col.end() );
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq %rsi, (%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x6, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x52d9c
movq (%r14), %rax
movq (%rax), %r15... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TextFlow::Columns::iterator::iterator(Catch::TextFlow::Columns const&) | Columns::iterator::iterator( Columns const& columns ):
m_columns( columns.m_columns ),
m_activeIterators( m_columns.size() ) {
m_iterators.reserve( m_columns.size() );
for ( auto const& col : m_columns ) {
m_iterators.push_back( col.begin() );
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq %rsi, (%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x6, %rax
movq %rax, 0x20(%rdi)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x52d9c
movq (%r14), %ra... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TextFlow::Columns::iterator::operator*[abi:cxx11]() const | std::string Columns::iterator::operator*() const {
std::string row, padding;
for ( size_t i = 0; i < m_columns.size(); ++i ) {
const auto width = m_columns[i].width();
if ( m_iterators[i] != m_columns[i].end() ) {
std::string col = *m_iterator... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %ebp, %ebp
movb %bpl, 0x10(%rdi)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %bpl, (%rax)
leaq 0x28(%rsp), %r15... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TextFlow::Columns::iterator::operator++() | Columns::iterator& Columns::iterator::operator++() {
for ( size_t i = 0; i < m_columns.size(); ++i ) {
if ( m_iterators[i] != m_columns[i].end() ) {
++m_iterators[i];
}
}
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x6, %rcx
cmpq %rcx, %r15
jae 0x40ec4
movq 0x8(%rbx), %rdi
movq (%rax,%r14), %rcx
addq 0x8(%rax,%r14), %rcx
cmpq %rcx, 0x10(%rdi,%r14)
jne 0x40eb3
addq %r14... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::WildcardPattern::WildcardPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::CaseSensitive) | WildcardPattern::WildcardPattern( std::string const& pattern,
CaseSensitive caseSensitivity )
: m_caseSensitivity( caseSensitivity ),
m_pattern( normaliseString( pattern ) )
{
if( startsWith( m_pattern, '*' ) ) {
m_pattern = m_pattern.substr( 1... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %r14
movl %edx, (%rdi)
andl $0x0, 0x4(%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x4104c
movq 0x10(%r14), %rcx
testq %rcx, %rcx
je 0x4102d
movq (%rbx), %rax
cmpb $0x2a, (%rax)
jne 0x40ffb
movq %rsp, %rdi
p... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::WildcardPattern::normaliseString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string WildcardPattern::normaliseString( std::string const& str ) const {
return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x1, (%rsi)
jne 0x41066
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x371db
jmp 0x41071
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x15860
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x319c8
movq %rsp, %rdi
callq 0x15c18
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
mo... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlEncode::encodeTo(std::ostream&) const | void XmlEncode::encodeTo( std::ostream& os ) const {
// Apostrophe escaping not necessary if we always use " to write attributes
// (see: http://www.w3.org/TR/xml/#syntax)
for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
unsigned char c = static_cast<unsigned char>(m_str[idx... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x2b58b(%rip), %r12 # 0x6c65b
pushq $0x22
popq %r13
leaq 0x2b570(%rip), %r15 # 0x6c64b
movq 0x8(%r14), %rcx
cmpq %rcx, %rbp
jae 0x412f2
movq (%r14), %rax
movzbl (%rax,%rbp), %esi
cmp... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::hexEscapeChar(std::ostream&, unsigned char) | void hexEscapeChar(std::ostream& os, unsigned char c) {
std::ios_base::fmtflags f(os.flags());
os << "\\x"
<< std::uppercase << std::hex << std::setfill('0') << std::setw(2)
<< static_cast<int>(c);
os.flags(f);
} | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %r14d
leaq 0x2c2a5(%rip), %rsi # 0x6d5c2
callq 0x15630
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
orl $0x4000, 0x18(%rax,%rdx) # imm = 0x4000
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %ed... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlWriter::endElement(Catch::XmlFormatting) | XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
m_indent = m_indent.substr(0, m_indent.size() - 2);
if( m_tagIsOpen ) {
m_os << "/>";
m_tagIsOpen = false;
} else {
newlineIfNecessary();
if (shouldIndent(fmt)) {
m_os << m_inde... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq 0x28(%rdi), %rcx
addq $-0x2, %rcx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x156c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x157c0
movq %r15, %rdi
callq 0x15c18
cmpb $0... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlWriter::writeAttribute(Catch::StringRef, Catch::StringRef) | XmlWriter& XmlWriter::writeAttribute( StringRef name,
StringRef attribute ) {
if( !name.empty() && !attribute.empty() )
m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
return *this;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rdi, %rbx
testq %rdx, %rdx
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
jne 0x41650
movq %r8, %r14
movq %rdx, %r12
movq %rsi, %r13
movq 0x40(%rbx), %rdi
pushq $0x20
popq %rsi
callq 0x15770
movq %rax, %rdi
movq %r13, %rsi
movq... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlWriter::XmlWriter(std::ostream&) | XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
{
writeDeclaration();
} | pushq %r15
pushq %r14
pushq %rbx
andw $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x20(%rdi), %r14
movb $0x0, 0x30(%rdi)
movq %rsi, 0x40(%rdi)
callq 0x416ba
popq %rbx
popq %r14
popq %r15
retq
mo... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlWriter::~XmlWriter() | XmlWriter::~XmlWriter() {
while (!m_tags.empty()) {
endElement();
}
newlineIfNecessary();
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
pushq $0x3
popq %rbp
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x416fc
movq %r14, %rdi
movl %ebp, %esi
callq 0x413f0
jmp 0x416e6
movq %r14, %rdi
callq 0x41726
addq $0x20, %r14
movq %r14, %rdi
callq 0x15c18
movq %rbx, %rdi
popq %rbx
popq %r14
popq... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlWriter::startElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::XmlFormatting) | XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
ensureTagClosed();
newlineIfNecessary();
if (shouldIndent(fmt)) {
m_os << m_indent;
m_indent += " ";
}
m_os << '<' << name;
m_tags.push_back( name );
m_tagI... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x417ca
movq %r14, %rdi
callq 0x41726
testb $0x1, %bl
je 0x4178b
movq 0x40(%r14), %rdi
leaq 0x20(%r14), %r12
movq %r12, %rsi
callq 0x155a0
leaq 0x2b79e(%rip), %rsi # 0x6cf21
movq %r12, %rdi
callq 0x15b60
mov... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlWriter::writeComment(Catch::StringRef, Catch::XmlFormatting) | XmlWriter& XmlWriter::writeComment( StringRef text, XmlFormatting fmt ) {
ensureTagClosed();
if (shouldIndent(fmt)) {
m_os << m_indent;
}
m_os << "<!-- " << text << " -->";
applyFormatting(fmt);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x417ca
testb $0x1, %bl
je 0x418c2
movq 0x40(%r14), %rdi
leaq 0x20(%r14), %rsi
callq 0x155a0
movq 0x40(%r14), %rdi
leaq 0x2adc2(%rip), %rsi # 0x6c68f
callq 0x15630
movq %rax, %rdi
movq %r12, ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Matchers::HasSizeMatcher::describe[abi:cxx11]() const | std::string HasSizeMatcher::describe() const {
ReusableStringStream sstr;
sstr << "has size == " << m_target_size;
return sstr.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x3c508
movq 0x8(%r15), %rdi
leaq 0x2ad09(%rip), %rsi # 0x6c6f2
callq 0x15630
addq $0x28, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x52eb6
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
ca... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Matchers::SizeIs(unsigned long) | HasSizeMatcher SizeIs(std::size_t sz) {
return HasSizeMatcher{ sz };
} | movq %rdi, %rax
leaq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x637b5(%rip), %rcx # 0xa5228
movq %rcx, (%rdi)
movq %rsi, 0x28(%rdi)
retq
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Matchers::WithinAbsMatcher::describe[abi:cxx11]() const | std::string WithinAbsMatcher::describe() const {
return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x30, %rsi
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x50b1a
leaq 0x2ab16(%rip), %rsi # 0x6c74c
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0x17d44
leaq 0x2ab73(%rip), %rdx # 0x6c7bd
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Matchers::Detail::finalizeDescription(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string Catch::Matchers::Detail::finalizeDescription(const std::string& desc) {
if (desc.empty()) {
return "matches undescribed predicate";
} else {
return "matches predicate: \"" + desc + '"';
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x423f6
movq %rsi, %rdx
leaq 0x2a4b7(%rip), %rsi # 0x6c886
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2afc7
pushq $0x22
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ceda
leaq 0x8(%rsp), %rdi
callq 0x15c18
jmp 0x4240a
leaq 0x2a46b... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
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.