name string | code string | asm string | file string |
|---|---|---|---|
Catch::Matchers::RegexMatcher::describe[abi:cxx11]() const | std::string RegexMatcher::describe() const {
return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Yes)? " case sensitively" : " case insensitively");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x37a3e
leaq 0x2a033(%rip), %rsi # 0x6c914
movq %rsp, %rdi
movq %r15, %rdx
callq 0x17d44
cmpl $0x0, 0x48(%r14)
leaq 0x2a025(%rip), %rax # 0x6c91d
leaq 0x2a030(%rip), %rd... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::ReporterBase::ReporterBase(Catch::ReporterConfig&&) | ReporterBase::ReporterBase( ReporterConfig&& config ):
IEventListener( config.fullConfig() ),
m_wrapped_stream( CATCH_MOVE(config).takeStream() ),
m_stream( m_wrapped_stream->stream() ),
m_colour( makeColourImpl( config.colourMode(), m_wrapped_stream.get() ) ),
m_customOptions( c... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
andw $0x0, 0x8(%rdi)
leaq 0x61d35(%rip), %rax # 0xa4960
movq %rax, (%rdi)
movdqu (%rsi), %xmm0
pshufd $0x4e, %xmm0, %xmm0 # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x10(%rdi)
andq $0x0, (%rsi)
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
m... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::defaultListReporters(std::ostream&, std::vector<Catch::ReporterDescription, std::allocator<Catch::ReporterDescription>> const&, Catch::Verbosity) | void
defaultListReporters( std::ostream& out,
std::vector<ReporterDescription> const& descriptions,
Verbosity verbosity ) {
out << "Available reporters:\n";
const auto maxNameLen =
std::max_element( descriptions.begin(),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x29d76(%rip), %rsi # 0x6caa7
callq 0x15630
movq (%r15), %r14
movq 0x8(%r15), %r13
movq %r14, %rax
cmpq %r13, %r14
je 0x42d6a
leaq 0x40(%r14), %rcx
movq %r14, %rax
cmpq %r13, ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::defaultListListeners(std::ostream&, std::vector<Catch::ListenerDescription, std::allocator<Catch::ListenerDescription>> const&) | void defaultListListeners( std::ostream& out,
std::vector<ListenerDescription> const& descriptions ) {
out << "Registered listeners:\n";
if(descriptions.empty()) {
return;
}
const auto maxNameLen =
std::max_element( descriptions.be... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x29b72(%rip), %rsi # 0x6cabd
callq 0x15630
movq (%r15), %r14
movq 0x8(%r15), %r12
cmpq %r12, %r14
je 0x43098
movq %rbx, (%rsp)
leaq 0x30(%r14), %rax
movq %r14, %rcx
movq 0x8(%rcx), %r13
cmpq %r12... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::defaultListTags(std::ostream&, std::vector<Catch::TagInfo, std::allocator<Catch::TagInfo>> const&, bool) | void defaultListTags( std::ostream& out,
std::vector<TagInfo> const& tags,
bool isFiltered ) {
if ( isFiltered ) {
out << "Tags for matching test cases:\n";
} else {
out << "All available tags:\n";
}
for ( auto ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %rbx
leaq 0x29628(%rip), %rax # 0x6cad4
leaq 0x29640(%rip), %rsi # 0x6caf3
testl %edx, %edx
cmovneq %rax, %rsi
movq %rdi, (%rsp)
callq 0x15630
movq (%rbx), %r15
movq %rbx, 0x18(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x2... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::CompactReporter::assertionEnded(Catch::AssertionStats const&) | void CompactReporter::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->includeSucces... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movb $0x1, %cl
testb %al, %al
jne 0x4380c
movl 0x88(%r14), %eax
testb $0x10, %al
je 0x437fc
movl 0x30(%r14), %edx
andl $0x8, %edx
je 0x4380c
xorl %ecx, %ecx
cmpl $0x4, %... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::ConsoleReporter::testRunEnded(Catch::TestRunStats const&) | void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
printTotalsDivider(_testRunStats.totals);
printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
m_stream << '\n' << std::flush;
StreamingReporterBase::testRunEnded(_testRunStats);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rsi), %r14
movq %r14, %rsi
callq 0x4577a
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq %r14, %rdx
callq 0x43cc9
movq 0x20(%rbx), %rdi
pushq $0xa
popq %rsi
callq 0x15770
movq %rax, %rdi
callq 0x15450
andq $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::ConsoleReporter::lazyPrintRunInfo() | void ConsoleReporter::lazyPrintRunInfo() {
m_stream << '\n'
<< lineOfChars( '~' ) << '\n'
<< m_colour->guardColour( Colour::SecondaryText )
<< currentTestRunInfo.name << " is a Catch2 v" << libraryVersion()
<< " host application.\n"
<< "Run with -? fo... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
pushq $0xa
popq %rbp
movl %ebp, %esi
callq 0x15770
movq %rax, %r14
pushq $0x7e
popq %rsi
movq %rax, %rdi
callq 0x45e7f
movq %r14, %rdi
movl %ebp, %esi
callq 0x15770
movq %rax, %r14
movq 0x28(%rbx), %rdi
movq %rdi, (%rsp)
movl $0x17,... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::ConsoleReporter::printTestCaseAndSectionHeader() | void ConsoleReporter::printTestCaseAndSectionHeader() {
assert(!m_sectionStack.empty());
printOpenHeader(currentTestCaseInfo->name);
if (m_sectionStack.size() > 1) {
auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
auto
it = m_sectionStack.begin() + 1, ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rsi
callq 0x45ea8
movq 0x80(%rbx), %rcx
movq %rcx, %rax
subq 0x78(%rbx), %rax
pushq $0x30
popq %rsi
cqto
idivq %rsi
cmpq $0x2, %rax
jb 0x45dcb
movq 0x28(%rbx), %r14
movq %r14, (%rsp)
movl $0x1, 0x8(%rsp)
movb $0x1, 0xc(%rsp)
... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::ConsoleReporter::printHeaderString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
// We want to get a bit fancy with line breaking here, so that subsequent
// lines start after ":" if one is present, e.g.
// ```
// blablabla: Fancy
// linebreaking
// ```
// but we also wan... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2647d(%rip), %rsi # 0x6c3e8
xorl %r12d, %r12d
movq %r15, %rdi
xorl %edx, %edx
callq 0x15bb0
leaq 0x2(%rax), %r13
cmpq $0x14, %rax
cmovaeq %r12, %r13
movq 0x20(%rbx), %rbx
movq %rsp, %r12
mo... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::findMax(unsigned long&, unsigned long&, unsigned long&, unsigned long&) | std::size_t&
findMax( std::size_t& i, std::size_t& j, std::size_t& k, std::size_t& l ) {
if (i > j && i > k && i > l)
return i;
else if (j > k && j > l)
return j;
else if (k > l)
return k;
else
return l;
} | movq %rdi, %rax
movq (%rdi), %r10
movq (%rsi), %r8
cmpq %r8, %r10
seta %r9b
movq (%rdx), %rdi
cmpq %rdi, %r10
seta %r11b
andb %r9b, %r11b
movq (%rcx), %r9
cmpq %r9, %r10
seta %r10b
testb %r10b, %r11b
jne 0x46052
cmpq %rdi, %r8
seta %r10b
cmpq %r9, %r8
seta %r8b
movq %rsi, %rax
testb %r8b, %r10b
jne 0x46052
cmpq %r9, %r... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::CumulativeReporterBase::assertionEnded(Catch::AssertionStats const&) | void CumulativeReporterBase::assertionEnded(
AssertionStats const& assertionStats ) {
assert( !m_sectionStack.empty() );
// AssertionResult holds a pointer to a temporary DecomposedExpression,
// which getExpandedExpression() calls to build the expression string.
// Our section s... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x61(%rdi)
jne 0x463c4
testb $0x10, 0x88(%rbx)
je 0x463c4
movl 0x30(%rbx), %eax
andl $0x8, %eax
jne 0x463c4
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x314a4
movq %r15, %rdi
callq 0x15c18
cmpb $0x1, 0x60(%r14)... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::CumulativeReporterBase::testCaseEnded(Catch::TestCaseStats const&) | void CumulativeReporterBase::testCaseEnded(
TestCaseStats const& testCaseStats ) {
auto node = Detail::make_unique<TestCaseNode>( testCaseStats );
assert( m_sectionStack.size() == 0 );
node->children.push_back( CATCH_MOVE(m_rootSection) );
m_testCases.push_back( CATCH_MOVE(node) ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x53287
movl $0x90, %edi
addq (%r15), %rdi
leaq 0x88(%r14), %rsi
callq 0x636cc
leaq 0x70(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x63b96
leaq 0x48(%rbx), %rsi
movl $0x90, %edi
addq 0x90(%r14), %rd... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::serializeFilters(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | std::string serializeFilters( std::vector<std::string> const& filters ) {
// We add a ' ' separator between each filter
size_t serialized_size = filters.size() - 1;
for (auto const& filter : filters) {
serialized_size += filter.size();
}
std::string serialized;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x5, %rsi
decq %rsi
cmpq %rcx, %rax
je 0x4663d
addq 0x8(%rax), %rsi
addq $0x20, %rax
jmp 0x4662e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::SummaryColumn::addRow(unsigned long) && | SummaryColumn&& addRow( std::uint64_t count ) && {
std::string row = std::to_string(count);
auto const new_width = std::max( m_width, row.size() );
if ( new_width > m_width ) {
for ( auto& oldRow : m_rows ) {
oldRow.insert( 0, n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x53999
movq 0x8(%r14), %r15
movq 0x28(%rbx), %rax
movq %rax, %rdx
subq %r15, %rdx
cmovaq %rax, %r15
jae 0x4683b
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %r12
pushq $0x20
popq %rbp
cmpq %r12, %r14... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JsonReporter::JsonReporter(Catch::ReporterConfig&&) | JsonReporter::JsonReporter( ReporterConfig&& config ):
StreamingReporterBase{ CATCH_MOVE( config ) } {
m_preferences.shouldRedirectStdOut = true;
// TBD: Do we want to report all assertions? XML reporter does
// not, but for machine-parseable reporters I think the answer
//... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, %rbx
callq 0x52f56
leaq 0x5e141(%rip), %rax # 0xa4bd8
movq %rax, (%rbx)
andq $0x0, 0x90(%rbx)
leaq 0x98(%rbx), %r14
movq %r14, %rdi
callq 0x53326
leaq 0xe8(%rbx), %r15
movq %r15, %rdi
callq 0x53342
leaq 0x13... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JsonReporter::~JsonReporter() | JsonReporter::~JsonReporter() {
endListing();
// TODO: Ensure this closes the top level object, add asserts
assert( m_writers.size() == 1 && "Only the top level object should be open" );
assert( m_writers.top() == Writer::Object );
endObject();
m_stream << '\n' << std::fl... | pushq %rbx
movq %rdi, %rbx
leaq 0x5deb1(%rip), %rax # 0xa4bd8
movq %rax, (%rdi)
callq 0x46d80
movq %rbx, %rdi
callq 0x46d9e
movq 0x20(%rbx), %rdi
pushq $0xa
popq %rsi
callq 0x15770
movq %rax, %rdi
callq 0x15450
leaq 0x138(%rbx), %rdi
callq 0x58fc2
leaq 0xe8(%rbx), %rdi
callq 0x5901a
leaq 0x98(%rbx), %rdi
callq 0x59... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JsonReporter::~JsonReporter() | JsonReporter::~JsonReporter() {
endListing();
// TODO: Ensure this closes the top level object, add asserts
assert( m_writers.size() == 1 && "Only the top level object should be open" );
assert( m_writers.top() == Writer::Object );
endObject();
m_stream << '\n' << std::fl... | pushq %rbx
movq %rdi, %rbx
callq 0x46d1c
movl $0x190, %esi # imm = 0x190
movq %rbx, %rdi
popq %rbx
jmp 0x15670
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JsonReporter::startArray(Catch::StringRef) | JsonArrayWriter& JsonReporter::startArray( StringRef key ) {
m_arrayWriters.emplace(
m_objectWriters.top().write( key ).writeArray() );
m_writers.emplace( Writer::Array );
return m_arrayWriters.top();
} | pushq %r14
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0xc8(%rdi), %rsi
cmpq 0xd0(%rdi), %rsi
jne 0x46ec1
movq 0xe0(%rbx), %rax
movl $0x1f8, %esi # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JsonReporter::startObject() | JsonObjectWriter& JsonReporter::startObject() {
m_objectWriters.emplace( m_arrayWriters.top().writeObject() );
m_writers.emplace( Writer::Object );
return m_objectWriters.top();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x98(%rdi), %r14
movq 0x118(%rdi), %rsi
cmpq 0x120(%rdi), %rsi
jne 0x46fa7
movq 0x130(%rbx), %rax
movl $0x1f8, %esi # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3b4fa
movq %r14, %rdi
m... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JsonReporter::startObject(Catch::StringRef) | JsonObjectWriter& JsonReporter::startObject( StringRef key ) {
m_objectWriters.emplace(
m_objectWriters.top().write( key ).writeObject() );
m_writers.emplace( Writer::Object );
return m_objectWriters.top();
} | pushq %r14
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0xc8(%rdi), %rsi
cmpq 0xd0(%rdi), %rsi
jne 0x4705b
movq 0xe0(%rbx), %rax
movl $0x1f8, %esi # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::writeCounts(Catch::JsonObjectWriter&&, Catch::Counts const&) | static void writeCounts( JsonObjectWriter&& writer, Counts const& counts ) {
writer.write( "passed"_sr ).write( counts.passed );
writer.write( "failed"_sr ).write( counts.failed );
writer.write( "fail-but-ok"_sr ).write( counts.failedButOk );
writer.write( "skipped"_sr ).write( counts.sk... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2580a(%rip), %rdx # 0x6cb68
leaq 0x8(%rsp), %r15
pushq $0x6
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b404
movq %r15, %rdi
movq %rbx, %rsi
callq 0x533b2
leaq 0x10(%rsp), %rdi
callq 0x154d0
lea... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JsonReporter::testCaseStarting(Catch::TestCaseInfo const&) | void JsonReporter::testCaseStarting( TestCaseInfo const& tcInfo ) {
StreamingReporterBase::testCaseStarting( tcInfo );
assert( isInside( Writer::Array ) &&
"We should be in the 'test-cases' array" );
startObject();
// "test-info" prelude
{
auto testIn... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f0, %rsp # imm = 0x1F0
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x70(%rdi)
callq 0x46f74
movq 0xc8(%rbx), %rsi
cmpq 0xd0(%rbx), %rsi
jne 0x47481
movq 0xe0(%rbx), %rax
movl $0x1f8, %esi # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::writeSourceInfo(Catch::JsonObjectWriter&, Catch::SourceLineInfo const&) | void writeSourceInfo( JsonObjectWriter& writer,
SourceLineInfo const& sourceInfo ) {
auto source_location_writer =
writer.write( "source-location"_sr ).writeObject();
source_location_writer.write( "filename"_sr )
.write( sourceInfo.fi... | pushq %r14
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x261a2(%rip), %rdx # 0x6d85e
leaq 0x20(%rsp), %r14
pushq $0xf
popq %rcx
movq %r14, %rdi
callq 0x3b404
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3b5c2
leaq 0x28(%rsp), %rdi
callq 0x154d0
leaq 0x24673(%rip), %rdx... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JsonReporter::testCasePartialStarting(Catch::TestCaseInfo const&, unsigned long) | void JsonReporter::testCasePartialStarting( TestCaseInfo const& /*tcInfo*/,
uint64_t index ) {
startObject();
m_objectWriters.top().write( "run-idx"_sr ).write( index );
startArray( "path"_sr );
// TODO: we want to delay most of the printin... | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
callq 0x46f74
movq 0xc8(%rbx), %rsi
cmpq 0xd0(%rbx), %rsi
jne 0x478e7
movq 0xe0(%rbx), %rax
movl $0x1f8, %esi # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
leaq 0x2534c(%rip), %rdx # 0x6cc3e
leaq... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JsonReporter::sectionStarting(Catch::SectionInfo const&) | void JsonReporter::sectionStarting( SectionInfo const& sectionInfo ) {
assert( isInside( Writer::Array ) &&
"Section should always start inside an object" );
// We want to nest top level sections, even though it shares name
// and source loc with the TEST_CASE
auto& secti... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
callq 0x46f74
movq %rax, %r15
leaq 0x2512e(%rip), %rdx # 0x6cc6b
movq %rsp, %r12
pushq $0x4
popq %rcx
movq %r12, %rdi
movq %rax, %rsi
callq 0x3b404
leaq 0x24ebe(%rip), %rsi # 0x6ca13
pushq $0x7... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JsonReporter::assertionEnded(Catch::AssertionStats const&) | void JsonReporter::assertionEnded( AssertionStats const& assertionStats ) {
// TODO: There is lot of different things to handle here, but
// we can fill it in later, after we show that the basic
// outline and streaming reporter impl works well enough.
//if ( !m_config->inclu... | pushq %r14
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, %rbx
movq 0x118(%rdi), %rsi
cmpq 0x120(%rdi), %rsi
jne 0x47c41
movq 0x130(%rdi), %rax
movl $0x1f8, %esi # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3b4fa
leaq 0x25012(%rip), %rdx... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JsonReporter::listListeners(std::vector<Catch::ListenerDescription, std::allocator<Catch::ListenerDescription>> const&) | void JsonReporter::listListeners(
std::vector<ListenerDescription> const& descriptions ) {
startListing();
auto writer =
m_objectWriters.top().write( "listeners"_sr ).writeArray();
for ( auto const& desc : descriptions ) {
auto desc_writer = writer.writeObject()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4715e
movq 0xc8(%r14), %rsi
cmpq 0xd0(%r14), %rsi
jne 0x47ec2
movq 0xe0(%r14), %rax
movl $0x1f8, %esi # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
leaq... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JsonReporter::listTests(std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>> const&) | void JsonReporter::listTests( std::vector<TestCaseHandle> const& tests ) {
startListing();
auto writer = m_objectWriters.top().write( "tests"_sr ).writeArray();
for ( auto const& test : tests ) {
auto desc_writer = writer.writeObject();
auto const& info = test.getTestCa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4715e
movq 0xc8(%r14), %rsi
cmpq 0xd0(%r14), %rsi
jne 0x4801e
movq 0xe0(%r14), %rax
movl $0x1f8, %esi # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
leaq... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JsonReporter::listTags(std::vector<Catch::TagInfo, std::allocator<Catch::TagInfo>> const&) | void JsonReporter::listTags( std::vector<TagInfo> const& tags ) {
startListing();
auto writer = m_objectWriters.top().write( "tags"_sr ).writeArray();
for ( auto const& tag : tags ) {
auto tag_writer = writer.writeObject();
{
auto aliases_writer =
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4715e
movq 0xc8(%r14), %rsi
cmpq 0xd0(%r14), %rsi
jne 0x48210
movq 0xe0(%r14), %rax
movl $0x1f8, %esi # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
leaq... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JunitReporter::JunitReporter(Catch::ReporterConfig&&) | JunitReporter::JunitReporter( ReporterConfig&& _config )
: CumulativeReporterBase( CATCH_MOVE(_config) ),
xml( m_stream )
{
m_preferences.shouldRedirectStdOut = true;
m_preferences.shouldReportAllAssertions = true;
m_shouldStoreSuccesfulAssertions = fals... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x533ba
leaq 0x5c911(%rip), %rax # 0xa4ca8
movq %rax, (%rbx)
leaq 0xb0(%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x41662
andq $0x0, 0xf8(%rbx)
leaq 0x110(%rbx), %rax
movq %rax, 0x100(%rbx)
andq $0x0, 0x108(%rbx)
xorl %eax, %eax
movb %al, 0x110(%rbx)
leaq 0x130(%r... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JunitReporter::testRunStarting(Catch::TestRunInfo const&) | void JunitReporter::testRunStarting( TestRunInfo const& runInfo ) {
CumulativeReporterBase::testRunStarting( runInfo );
xml.startElement( "testsuites" );
suiteTimer.start();
stdOutForSuite.clear();
stdErrForSuite.clear();
unexpectedExceptions = 0;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x2488d(%rip), %rsi # 0x6ccde
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x161da
leaq 0xb0(%rbx), %rdi
pushq $0x3
popq %rdx
movq %r14, %rsi
callq 0x4174a
leaq 0x8(%rsp), %rdi
callq 0x15c18
callq 0x15090
movq %rax, 0xf8(%rbx)
andq $0x0,... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JunitReporter::writeRun(Catch::CumulativeReporterBase::Node<Catch::TestRunStats, Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode>> const&, double) | void JunitReporter::writeRun( TestRunNode const& testRunNode, double suiteTime ) {
XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
TestRunStats const& stats = testRunNode.value;
xml.writeAttribute( "name"_sr, stats.runInfo.name );
xml.writeAttribute( "errors"_sr, unexpect... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %xmm0, 0x88(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2474f(%rip), %rsi # 0x6cce9
leaq 0x50(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x161da
leaq 0xb0(%rbx), %r14
leaq 0x90(%rsp), %rdi
leaq 0x50(%rsp), %rdx
pushq $0x3
popq %rcx
movq %r14... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::formatDuration[abi:cxx11](double) | std::string formatDuration( double seconds ) {
ReusableStringStream rss;
rss << std::fixed << std::setprecision( 3 ) << seconds;
return rss.str();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3c508
movq 0x8(%r14), %r14
movq (%r14), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx # imm = 0xFFFFFEFB
andl 0x18(%r14,%rcx), %edx
orl $0x4, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JunitReporter::writeTestCase(Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode> const&) | void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
TestCaseStats const& stats = testCaseNode.value;
// All test cases have exactly one section - which represents the
// test case itself. That section may have 0-n nested sections
assert( testCaseNode.children.size() ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq 0x90(%rsi), %rax
movq (%rax), %rax
movq %rax, 0x50(%rsp)
movq (%rsi), %rsi
addq $0x20, %rsi
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x50b9e
cmpq $0x0, 0x8(%rbx)
jne 0x48cec
movq (%r15), %rcx
... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JunitReporter::writeSection(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&, Catch::CumulativeReporterBase::SectionNode const&, bool) | void JunitReporter::writeSection( std::string const& className,
std::string const& rootName,
SectionNode const& sectionNode,
bool testOkToFail) {
std::string name = trim( sectionNode.stats.sectionIn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r8d, %ebp
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, 0x30(%rsp)
leaq 0x68(%rsp), %rdi
movq %rcx, %rsi
callq 0x319c8
cmpq $0x0, 0x8(%r14)
je 0x48eea
leaq 0x38(%rsp), %rdi
pushq $0x2f
popq %rdx
movq %r14, %rsi
callq 0... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JunitReporter::writeAssertions(Catch::CumulativeReporterBase::SectionNode const&) | void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
if (assertionOrBenchmark.isAssertion()) {
writeAssertion(assertionOrBenchmark.asAssertion());
}
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rsi), %r14
movq 0x80(%rsi), %r15
cmpq %r15, %r14
je 0x492df
movq (%r14), %rsi
testq %rsi, %rsi
je 0x492d6
movq %rbx, %rdi
callq 0x492e6
addq $0x1b8, %r14 # imm = 0x1B8
jmp 0x492c1
popq %rbx
popq %r14
popq %r15
retq
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::JunitReporter::writeAssertion(Catch::AssertionStats const&) | void JunitReporter::writeAssertion( AssertionStats const& stats ) {
AssertionResult const& result = stats.assertionResult;
if ( !result.isOk() ||
result.getResultType() == ResultWas::ExplicitSkip ) {
std::string elementName;
switch( result.getResultType() ) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x88(%rsi), %eax
testb $0x10, %al
je 0x4935d
movl 0x30(%r14), %ecx
andl $0x8, %ecx
jne 0x4935d
leaq 0x70(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0x22803(%rip), %rsi # ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::MultiReporter::noMatchingTestCases(Catch::StringRef) | void MultiReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
for ( auto& reporterish : m_reporterLikes ) {
reporterish->noMatchingTestCases( unmatchedSpec );
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
cmpq %r12, %r15
je 0x4970a
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
addq $0x8, %r15
jmp 0x496f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
po... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::MultiReporter::fatalErrorEncountered(Catch::StringRef) | void MultiReporter::fatalErrorEncountered( StringRef error ) {
for ( auto& reporterish : m_reporterLikes ) {
reporterish->fatalErrorEncountered( error );
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
cmpq %r12, %r15
je 0x49749
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x98(%rax)
addq $0x8, %r15
jmp 0x4972c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
po... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::MultiReporter::reportInvalidTestSpec(Catch::StringRef) | void MultiReporter::reportInvalidTestSpec( StringRef arg ) {
for ( auto& reporterish : m_reporterLikes ) {
reporterish->reportInvalidTestSpec( arg );
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
cmpq %r12, %r15
je 0x49786
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
addq $0x8, %r15
jmp 0x4976c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
po... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::MultiReporter::benchmarkPreparing(Catch::StringRef) | void MultiReporter::benchmarkPreparing( StringRef name ) {
for (auto& reporterish : m_reporterLikes) {
reporterish->benchmarkPreparing(name);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
cmpq %r12, %r15
je 0x497c2
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x40(%rax)
addq $0x8, %r15
jmp 0x497a8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
po... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::MultiReporter::benchmarkStarting(Catch::BenchmarkInfo const&) | void MultiReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
for ( auto& reporterish : m_reporterLikes ) {
reporterish->benchmarkStarting( benchmarkInfo );
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r15
cmpq %r15, %r14
je 0x497f5
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x48(%rax)
addq $0x8, %r14
jmp 0x497de
popq %rbx
popq %r14
popq %r15
retq
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::MultiReporter::benchmarkEnded(Catch::BenchmarkStats<std::chrono::duration<double, std::ratio<1l, 1000000000l>>> const&) | void MultiReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
for ( auto& reporterish : m_reporterLikes ) {
reporterish->benchmarkEnded( benchmarkStats );
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r15
cmpq %r15, %r14
je 0x49823
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
addq $0x8, %r14
jmp 0x4980c
popq %rbx
popq %r14
popq %r15
retq
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::MultiReporter::benchmarkFailed(Catch::StringRef) | void MultiReporter::benchmarkFailed( StringRef error ) {
for (auto& reporterish : m_reporterLikes) {
reporterish->benchmarkFailed(error);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
cmpq %r12, %r15
je 0x4985a
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x58(%rax)
addq $0x8, %r15
jmp 0x49840
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
po... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::MultiReporter::testCasePartialStarting(Catch::TestCaseInfo const&, unsigned long) | void
MultiReporter::testCasePartialStarting( TestCaseInfo const& testInfo,
uint64_t partNumber ) {
for ( auto& reporterish : m_reporterLikes ) {
reporterish->testCasePartialStarting( testInfo, partNumber );
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
cmpq %r12, %r15
je 0x498f2
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x30(%rax)
addq $0x8, %r15
jmp 0x498d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
po... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::MultiReporter::sectionEnded(Catch::SectionStats const&) | void MultiReporter::sectionEnded( SectionStats const& sectionStats ) {
for ( auto& reporterish : m_reporterLikes ) {
reporterish->sectionEnded( sectionStats );
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r15
cmpq %r15, %r14
je 0x499db
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x70(%rax)
addq $0x8, %r14
jmp 0x499c4
popq %rbx
popq %r14
popq %r15
retq
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::MultiReporter::testCasePartialEnded(Catch::TestCaseStats const&, unsigned long) | void MultiReporter::testCasePartialEnded( TestCaseStats const& testStats,
uint64_t partNumber ) {
if ( m_preferences.shouldRedirectStdOut &&
m_haveNoncapturingReporters ) {
if ( !testStats.stdOut.empty() ) {
Catch::cout()... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, 0x8(%rdi)
jne 0x49a3e
cmpb $0x1, 0x30(%r15)
jne 0x49a3e
cmpq $0x0, 0x50(%r14)
je 0x49a1f
leaq 0x48(%r14), %rsi
movq 0x5e586(%rip), %rdi # 0xa7f98
callq 0x155a0
movq %rax, %rdi
callq 0x15450
cmpq $0x0, 0... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::MultiReporter::testRunEnded(Catch::TestRunStats const&) | void MultiReporter::testRunEnded( TestRunStats const& testRunStats ) {
for ( auto& reporterish : m_reporterLikes ) {
reporterish->testRunEnded( testRunStats );
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r15
cmpq %r15, %r14
je 0x49ac8
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x88(%rax)
addq $0x8, %r14
jmp 0x49aae
popq %rbx
popq %r14
popq %r15
retq
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Detail::registerListenerImpl(Catch::Detail::unique_ptr<Catch::EventListenerFactory>) | void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory ) {
getMutableRegistryHub().registerListener( CATCH_MOVE(listenerFactory) );
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x4db2c
movq (%rbx), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
andq $0x0, (%rbx)
movq 0x8(%rax), %rcx
leaq 0x8(%rax), %rdi
callq *0x18(%rcx)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x49c8a
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::SonarQubeReporter::writeTestFile(Catch::StringRef, std::vector<Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode> const*, std::allocator<Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode> const*>> const&) | void SonarQubeReporter::writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes) {
XmlWriter::ScopedElement e = xml.scopedElement("file");
xml.writeAttribute("path"_sr, filename);
for (auto const& child : testCaseNodes)
writeTestCase(*child);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x21e3c(%rip), %rsi # 0x6bd2e
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x161da
leaq 0xb0(%rbx), %r13
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rdx
pushq $0x3
popq %rcx
m... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::SonarQubeReporter::writeTestCase(Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode> const&) | void SonarQubeReporter::writeTestCase(TestCaseNode const& testCaseNode) {
// All test cases have exactly one section - which represents the
// test case itself. That section may have 0-n nested sections
assert(testCaseNode.children.size() == 1);
SectionNode const& rootSection = *testCase... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x90(%rsi), %rax
movq (%rax), %r15
leaq 0x22e1f(%rip), %rsi # 0x6cde1
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x161da
movq (%rbx), %rax
xorl %ecx, %ecx
testb $0xc, 0x78(%rax)
setne %cl
movq %r14... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::escape[abi:cxx11](Catch::StringRef) | std::string escape(StringRef str) {
std::string escaped = static_cast<std::string>(str);
replaceInPlace(escaped, "|", "||");
replaceInPlace(escaped, "'", "|'");
replaceInPlace(escaped, "\n", "|n");
replaceInPlace(escaped, "\r", "|r");
replaceInPlac... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x48(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq %rax, %rsi
callq 0x50b9e
leaq 0x22e10(%rip), %rsi # 0x6d8d3
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x161da
leaq 0x22df9(%rip), %rsi # 0x6d8d2
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %r... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TeamCityReporter::assertionEnded(Catch::AssertionStats const&) | void TeamCityReporter::assertionEnded(AssertionStats const& assertionStats) {
AssertionResult const& result = assertionStats.assertionResult;
if ( !result.isOk() ||
result.getResultType() == ResultWas::ExplicitSkip ) {
ReusableStringStream msg;
if (!m_headerPrintedF... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, (%rsp)
movl 0x30(%rsi), %ecx
movl 0x88(%rsi), %eax
testb $0x8, %cl
sete %cl
cmpl $0x4, %eax
je 0x4ada8
shrb $0x4, %al
andb %cl, %al
je 0x4b0e7
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x3c508
movq 0x8(%r15),... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TeamCityReporter::testCaseStarting(Catch::TestCaseInfo const&) | void TeamCityReporter::testCaseStarting(TestCaseInfo const& testInfo) {
m_testTimer.start();
StreamingReporterBase::testCaseStarting(testInfo);
m_stream << "##teamcity[testStarted name='"
<< escape(testInfo.name) << "']\n";
m_stream.flush();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x15090
movq %rax, 0x98(%rbx)
movq %r14, 0x70(%rbx)
movq 0x20(%rbx), %rdi
leaq 0x21c63(%rip), %rsi # 0x6cf8d
callq 0x15630
movq %rax, %r15
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x4aa9e
movq... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlReporter::testRunStarting(Catch::TestRunInfo const&) | void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
StreamingReporterBase::testRunStarting( testInfo );
std::string stylesheetRef = getStylesheetRef();
if( !stylesheetRef.empty() )
m_xml.writeStylesheetRef( stylesheetRef );
m_xml.startElement("Catch2TestRun")
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, 0x60(%rdi)
movq (%rdi), %rax
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *0xc0(%rax)
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x4b6c5
leaq 0x98(%rbx), %rdi
movq 0x30(%rsp), %rsi
callq 0x41908
leaq 0x2197... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlReporter::sectionEnded(Catch::SectionStats const&) | void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
StreamingReporterBase::sectionEnded( sectionStats );
if ( --m_sectionDepth > 0 ) {
{
XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
e.writeAttribute( "successes"_sr, se... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r15
addq $0x78, %rdi
callq 0x5885e
movl 0xe0(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xe0(%r15)
cmpl $0x2, %eax
jl 0x4bff4
leaq 0x21199(%rip), %rsi # 0x6d0b8
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x161da
leaq 0x... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlReporter::testCaseEnded(Catch::TestCaseStats const&) | void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
StreamingReporterBase::testCaseEnded( testCaseStats );
XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
e.writeAttribute( "success"_sr, testCaseStats.totals.assertions.allOk() );
e.writeAttribute(... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
andq $0x0, 0x70(%rdi)
leaq 0x210ab(%rip), %rsi # 0x6d0f4
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x161da
leaq 0x98(%r15), %rbx
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
pushq $0x3
popq %rcx
movq %rbx, %rsi
callq ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlReporter::testRunEnded(Catch::TestRunStats const&) | void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
StreamingReporterBase::testRunEnded( testRunStats );
m_xml.scopedElement( "OverallResults" )
.writeAttribute( "successes"_sr, testRunStats.totals.assertions.passed )
.writeAttribute( "failures"_sr, testRunStats.... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x70(%rdi)
leaq 0x20e75(%rip), %rsi # 0x6d0b8
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x161da
addq $0x98, %rbx
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rdx
pushq $0x3
popq %rcx
movq %rbx, %rsi
callq 0x41800
leaq 0x1... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlReporter::benchmarkStarting(Catch::BenchmarkInfo const&) | void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
m_xml.writeAttribute("samples"_sr, info.samples)
.writeAttribute("resamples"_sr, info.resamples)
.writeAttribute("iterations"_sr, info.iterations)
.writeAttribute("clockResolution"_sr, info.clockResolution)
... | pushq %rbx
movq %rsi, %rbx
addq $0x98, %rdi
leaq 0x2c(%rsi), %rcx
leaq 0x21241(%rip), %rsi # 0x6d69f
pushq $0x7
popq %rdx
callq 0x533f8
leaq 0x30(%rbx), %rcx
leaq 0x1fbd2(%rip), %rsi # 0x6c043
pushq $0x9
popq %rdx
movq %rax, %rdi
callq 0x533f8
leaq 0x28(%rbx), %rcx
leaq 0x21222(%rip), %rsi # 0x6d6a9
pushq $... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlReporter::benchmarkFailed(Catch::StringRef) | void XmlReporter::benchmarkFailed(StringRef error) {
m_xml.scopedElement("failed").
writeAttribute("message"_sr, error);
m_xml.endElement();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x98, %rbx
leaq 0x206e0(%rip), %rsi # 0x6ce8c
leaq 0x18(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x161da
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rcx
movq %rbx, %rsi
movq %r12, %rdx
callq 0x... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlReporter::listReporters(std::vector<Catch::ReporterDescription, std::allocator<Catch::ReporterDescription>> const&) | void XmlReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
auto outerTag = m_xml.scopedElement("AvailableReporters");
for (auto const& reporter : descriptions) {
auto inner = m_xml.scopedElement("Reporter");
m_xml.startElement("Name", XmlFormatting::I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20986(%rip), %rsi # 0x6d1db
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x161da
addq $0x98, %rbx
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
pushq $0x3
popq %rcx
movq %rbx, %rsi
callq 0x41... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlReporter::listListeners(std::vector<Catch::ListenerDescription, std::allocator<Catch::ListenerDescription>> const&) | void XmlReporter::listListeners(std::vector<ListenerDescription> const& descriptions) {
auto outerTag = m_xml.scopedElement( "RegisteredListeners" );
for ( auto const& listener : descriptions ) {
auto inner = m_xml.scopedElement( "Listener" );
m_xml.startElement( "Name", XmlForma... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x207f3(%rip), %rsi # 0x6d1fa
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x161da
addq $0x98, %rbx
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
pushq $0x3
popq %rcx
movq %rbx, %rsi
callq 0x41... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::XmlReporter::listTests(std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>> const&) | void XmlReporter::listTests(std::vector<TestCaseHandle> const& tests) {
auto outerTag = m_xml.scopedElement("MatchingTests");
for (auto const& test : tests) {
auto innerTag = m_xml.scopedElement("TestCase");
auto const& testInfo = test.getTestCaseInfo();
m_xml.startEl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2067e(%rip), %rsi # 0x6d23a
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x161da
addq $0x98, %rbx
leaq 0x68(%rsp), %rdi
leaq 0x30(%rsp), %rdx
pushq $0x3
popq %rcx
movq %rbx, %rsi
callq 0x41... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::AssertionPrinter::printReconstructedExpression() const | void printReconstructedExpression() const {
if (result.hasExpandedExpression()) {
stream << colourImpl->guardColour(compactDimColour) << " for: ";
stream << result.getExpandedExpression();
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x31430
testb %al, %al
je 0x4d519
movq (%rbx), %r14
movq 0x28(%rbx), %rdi
movq %rdi, 0x8(%rsp)
movl $0x17, 0x10(%rsp)
movb $0x1, 0x14(%rsp)
movq (%rdi), %rax
pushq $0x17
popq %rsi
callq *0x10(%rax)
leaq 0x20173(%rip), %rsi # 0x6d651
m... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::AssertionPrinter::printRemainingMessages(Catch::Colour::Code) | void printRemainingMessages(Colour::Code colour = compactDimColour) {
if (itMessage == messages.end())
return;
const auto itEnd = messages.cend();
const auto N = static_cast<std::size_t>(itEnd - itMessage);
stream << colourImpl->guardColour( colour ) << " with "
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
movq 0x8(%rax), %r13
cmpq %r13, %rcx
je 0x4d651
movq %rdi, %rbx
movq %r13, %rax
subq %rcx, %rax
pushq $0x48
popq %rcx
cqto
idivq %rcx
movq %rax, %r14
movq (%rdi), %r15
movq 0x28(%rdi), %rdi
mov... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::AssertionPrinter::printMessage() | void printMessage() {
if (itMessage != messages.end()) {
stream << " '" << itMessage->message << '\'';
++itMessage;
}
} | movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
cmpq 0x8(%rax), %rcx
je 0x4d6de
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x2029e(%rip), %rsi # 0x6d956
callq 0x15630
movq 0x18(%rbx), %rsi
addq $0x10, %rsi
movq %rax, %rdi
callq 0x155a0
pushq $0x27
popq %rsi
movq %rax, %rdi
callq 0x15770
addq $0x48, 0x18(%rbx)
po... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::AssertionPrinter::printExpressionWas() | void printExpressionWas() {
if (result.hasExpression()) {
stream << ';';
{
stream << colourImpl->guardColour(compactDimColour) << " expression was:";
}
printOriginalExpression();
}
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rdi), %rax
cmpq $0x0, 0x28(%rax)
je 0x4d74a
movq %rdi, %rbx
movq (%rdi), %rdi
pushq $0x3b
popq %rsi
callq 0x15770
movq (%rbx), %r14
movq 0x28(%rbx), %rdi
movq %rdi, 0x8(%rsp)
movl $0x17, 0x10(%rsp)
movb $0x1, 0x14(%rsp)
movq (%rdi), %rax
pushq $0x17
popq %rsi
callq *0x10... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::TapAssertionPrinter::printReconstructedExpression() const | void printReconstructedExpression() const {
if (result.hasExpandedExpression()) {
stream << colourImpl->guardColour( tapDimColour ) << " for: ";
std::string expr = result.getExpandedExpression();
std::replace(expr.begin(), expr.end(), '\n', ' ... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x31430
testb %al, %al
je 0x4d8a3
movq (%rbx), %r14
movq 0x30(%rbx), %rdi
movq %rdi, 0x8(%rsp)
movl $0x17, 0x10(%rsp)
movb $0x1, 0x14(%rsp)
movq (%rdi), %rax
pushq $0x17
popq %rsi
callq *0x10(%rax)
leaq 0x1fe05(%rip), %rsi # 0x6d651
m... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::TapAssertionPrinter::printMessage() | void printMessage() {
if (itMessage != messages.end()) {
stream << " '" << itMessage->message << '\'';
++itMessage;
}
} | movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
cmpq 0x8(%rax), %rcx
je 0x4daa0
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x1fedc(%rip), %rsi # 0x6d956
callq 0x15630
movq 0x18(%rbx), %rsi
addq $0x10, %rsi
movq %rax, %rdi
callq 0x155a0
pushq $0x27
popq %rsi
movq %rax, %rdi
callq 0x15770
addq $0x48, 0x18(%rbx)
po... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::RegistryHub::registerListener(Catch::Detail::unique_ptr<Catch::EventListenerFactory>) | void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) override {
m_reporterRegistry.registerListener( CATCH_MOVE(factory) );
} | pushq %rbx
subq $0x10, %rsp
addq $0x98, %rdi
movq (%rsi), %rcx
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
andq $0x0, (%rsi)
movq %rax, %rsi
callq 0x3c2a2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4dd5b
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_2>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const& arg )
-> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
m_lambda, arg );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x15360
leaq 0x88(%rsp), %rax
andq $0x0, -0x18(%rax)
leaq 0x586f5(%rip), %r15 # 0xa7560
movq %... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_3>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const& arg )
-> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
m_lambda, arg );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x15360
leaq 0x90(%rsp), %rax
andq $0x0, -0x18(%rax)
leaq 0x5848e(%rip), %r15 # 0xa7560
movq %r15, -0x20(%rax)
... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_4>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const& arg )
-> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
m_lambda, arg );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x40(%rsp), %rdi
movq %rdx, %rsi
callq 0x15360
leaq 0x80(%rsp), %rax
andq $0x0, -0x18(%rax)
leaq 0x5828e(%rip), %r13 # 0xa... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_5>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const& arg )
-> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
m_lambda, arg );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x15360
leaq 0xa0(%rsp), %rax
andq $0x0, -0x18(%rax)
leaq 0x58060(%rip), %r15 # 0xa7560
movq %r15, -0x20(... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_8>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const& arg )
-> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
m_lambda, arg );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x15360
leaq 0x90(%rsp), %rax
andq $0x0, -0x18(%rax)
leaq 0x57e32(%rip), %r15 # 0xa7560
movq %r15, -0x20(... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_9>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const& arg )
-> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
m_lambda, arg );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x15360
leaq 0x90(%rsp), %rax
andq $0x0, -0x18(%rax)
leaq 0x57c3c(%rip), %r15 # 0xa7560
movq %r15, -0x20(%rax)
... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::(anonymous namespace)::ANSIColourImpl::use(Catch::Colour::Code) const | void use( Colour::Code _colourCode ) const override {
auto setColour = [&out =
m_stream->stream()]( char const* escapeCode ) {
// The escape sequence must be flushed to console, otherwise
// if stdin and stderr are intermixed, we'd get accide... | pushq %rbx
subq $0x50, %rsp
movl %esi, %ebx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x18(%rsp)
cmpl $0x17, %ebx
ja 0x4fb3c
movl %ebx, %eax
leaq 0x1a088(%rip), %rcx # 0x69ad8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1e181(%rip), %rsi # 0x6dbe1
jmp 0x4fac3
leaq 0x1e... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::(anonymous namespace)::ANSIColourImpl::use(Catch::Colour::Code) const::'lambda'(char const*)::operator()(char const*) const | void use( Colour::Code _colourCode ) const override {
auto setColour = [&out =
m_stream->stream()]( char const* escapeCode ) {
// The escape sequence must be flushed to console, otherwise
// if stdin and stderr are intermixed, we'd get accide... | pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rdi
pushq $0x1b
popq %rsi
callq 0x15770
movq %rax, %rdi
movq %rbx, %rsi
callq 0x15630
movq %rax, %rdi
popq %rbx
jmp 0x15450
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Detail::(anonymous namespace)::StreamBufImpl<Catch::Detail::(anonymous namespace)::OutputDebugWriter, 256ul>::overflow(int) | int overflow( int c ) override {
sync();
if( c != EOF ) {
if( pbase() == epptr() )
m_writer( std::string( 1, static_cast<char>( c ) ) );
else
sputc( static_cast<char>( c ) );
}
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x4fcb6
cmpl $-0x1, %ebx
je 0x4fd77
movq 0x20(%r14), %rax
cmpq 0x30(%r14), %rax
je 0x4fd49
movsbl %bl, %esi
movq %r14, %rdi
callq 0x15270
jmp 0x4fd77
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movsbl %bl, %edx
leaq 0x8(%rsp), %rbx
pushq $0x1... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::MessageBuilder::MessageBuilder(Catch::StringRef, Catch::SourceLineInfo const&, Catch::ResultWas::OfType) | MessageBuilder( StringRef macroName,
SourceLineInfo const& lineInfo,
ResultWas::OfType type ):
m_info(macroName, lineInfo, type) {} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x3c508
movq %r12, 0x10(%r13)
movq %r15, 0x18(%r13)
leaq 0x30(%r13), %rax
movq %rax, 0x20(%r13)
andq $0x0, 0x28(%r13)
movb $0x0, 0x30(%r13)
movups (%r14), %xmm0
movups %xmm0, 0x40... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::ParserBase::validate() const | virtual auto validate() const -> Result { return Result::ok(); } | movq %rdi, %rax
andl $0x0, 0x8(%rdi)
leaq 0x55dc0(%rip), %rcx # 0xa75e0
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.hpp |
Catch::JsonArrayWriter& Catch::JsonArrayWriter::writeImpl<bool>(bool const&) | JsonArrayWriter& writeImpl( T const& value ) {
JsonUtils::appendCommaNewline(
m_os, m_should_comma, m_indent_level + 1 );
JsonValueWriter{ m_os }.write( value );
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rsi
movq (%rdi), %rdi
movq 0x8(%rbx), %rdx
incq %rdx
callq 0x3b34c
movq (%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3b582
movzbl (%r14), %esi
movq %r15, %rdi
callq 0x3b6e2
leaq 0x1... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
int Catch::Session::run<char>(int, char const* const*) | int run(int argc, CharT const * const argv[]) {
if (m_startupExceptions)
return 1;
int returnCode = applyCommandLine(argc, argv);
if (returnCode == 0)
returnCode = run();
return returnCode;
} | pushq %rbx
cmpb $0x0, 0x178(%rdi)
je 0x51ff1
pushq $0x1
popq %rax
jmp 0x51ffd
movq %rdi, %rbx
callq 0x35704
testl %eax, %eax
je 0x51fff
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x359f6
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Detail::unique_ptr<Catch::ReporterRegistry::ReporterRegistryImpl> Catch::Detail::make_unique<Catch::ReporterRegistry::ReporterRegistryImpl>() | unique_ptr<T> make_unique(Args&&... args) {
return unique_ptr<T>(new T(CATCH_FORWARD(args)...));
} | pushq %rbx
movq %rdi, %rbx
pushq $0x48
popq %rdi
callq 0x15640
leaq 0x20(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq %rcx, 0x30(%rax)
movq %rcx, 0x38(%rax)
andq $0x0, 0x40(%rax)
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::StringStreams::add() | auto add() -> std::size_t {
if( m_unused.empty() ) {
m_streams.push_back( Detail::make_unique<std::ostringstream>() );
return m_streams.size()-1;
}
else {
auto index = m_unused.back();
m_unused.pop_back();
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
cmpq %rcx, 0x18(%rdi)
je 0x523b1
movq -0x8(%rcx), %rax
addq $-0x8, %rcx
movq %rcx, 0x20(%rbx)
jmp 0x523e4
movq %rsp, %r14
movq %r14, %rdi
callq 0x57ba1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x57be4
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x523d6
movq ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>> Catch::createShard<std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>>>(std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>> const&, unsigned long, unsigned long) | Container createShard(Container const& container, std::size_t const shardCount, std::size_t const shardIndex) {
assert(shardCount > shardIndex);
if (shardCount == 1) {
return container;
}
const std::size_t totalTestCount = container.size();
const std::size_t shardS... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x1, %rdx
jne 0x5286f
movq %rbx, %rdi
callq 0x5263c
jmp 0x528cd
movq %rdx, %r8
movq (%rsi), %rdi
movq 0x8(%rsi), %rax
subq %rdi, %rax
sarq $0x4, %rax
xorl %edx, %edx
divq %r8
movq %rax, %rsi
imulq %rcx, %rsi
cmpq %rcx, %rdx
movq %rcx, %r8
cmovbq %rdx, %r8
incq %rcx
imul... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Detail::unique_ptr<Catch::TestSpec::TagPattern> Catch::Detail::make_unique<Catch::TestSpec::TagPattern, char const (&) [2], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(char const (&) [2], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | unique_ptr<T> make_unique(Args&&... args) {
return unique_ptr<T>(new T(CATCH_FORWARD(args)...));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
pushq $0x48
popq %rdi
callq 0x15640
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r12, %rsi
callq 0x161da
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3738a
movq %rbx, (%r14)
le... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Detail::unique_ptr<Catch::TablePrinter> Catch::Detail::make_unique<Catch::TablePrinter, std::ostream&, std::vector<Catch::ColumnInfo, std::allocator<Catch::ColumnInfo>>>(std::ostream&, std::vector<Catch::ColumnInfo, std::allocator<Catch::ColumnInfo>>&&) | unique_ptr<T> make_unique(Args&&... args) {
return unique_ptr<T>(new T(CATCH_FORWARD(args)...));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0x15640
movq %rax, %r14
movups (%r15), %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
andq $0x0, 0x10(%... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<unsigned long, void>(Catch::StringRef, unsigned long const&) | XmlWriter& writeAttribute( StringRef name, T const& attribute ) {
ReusableStringStream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r13
movq %r13, %rdi
callq 0x3c508
movq %r13, %rdi
movq %r12, %rsi
callq 0x52eb6
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
leaq 0x10(%rsp), %rdi
callq 0x15970
movq 0x10(%rsp), %r... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<int, void>(Catch::StringRef, int const&) | XmlWriter& writeAttribute( StringRef name, T const& attribute ) {
ReusableStringStream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r13
movq %r13, %rdi
callq 0x3c508
movq %r13, %rdi
movq %r12, %rsi
callq 0x51ca4
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
leaq 0x10(%rsp), %rdi
callq 0x15970
movq 0x10(%rsp), %r... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<Catch::Version, void>(Catch::StringRef, Catch::Version const&) | XmlWriter& writeAttribute( StringRef name, T const& attribute ) {
ReusableStringStream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x3c508
movq 0x8(%r12), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x354fd
addq $0x8, %r12
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x15970
mov... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
unsigned long Catch::uniform_integer_distribution<unsigned long>::operator()<Catch::SimplePcg32>(Catch::SimplePcg32&) | result_type operator()( Generator& g ) {
// All possible values of result_type are valid.
if ( m_ab_distance == 0 ) {
return transposeBack( Detail::fillBitsFrom<UnsignedIntegerType>( g ) );
}
auto random_number = Detail::fillBitsFrom<UnsignedIntegerType>( g );
auto e... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq %rsi, %rdi
callq 0x5405b
movq %rax, %rdx
testq %r15, %r15
je 0x53ef7
movq %rdx, %rax
mulq 0x8(%rbx)
cmpq 0x10(%rbx), %rax
jae 0x53ef4
movq %r14, %rdi
callq 0x5405b
jmp 0x53ee0
addq (%rbx), %rdx
movq %rdx, %rax
popq %rbx
popq %r14... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
std::enable_if<sizeof (Catch::SimplePcg32::result_type) < sizeof (unsigned long), unsigned long>::type Catch::Detail::fillBitsFrom<unsigned long, Catch::SimplePcg32>(Catch::SimplePcg32&) | std::enable_if_t<sizeof(typename Generator::result_type) < sizeof(TargetType),
TargetType> fillBitsFrom(Generator& gen) {
using gresult_type = typename Generator::result_type;
static_assert( std::is_unsigned<TargetType>::value,
"Only unsigned integers are s... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, %bpl
xorl %eax, %eax
movq %rax, %r14
shlq $0x20, %r14
movq %rbx, %rdi
callq 0x383f0
movl %eax, %eax
orq %r14, %rax
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x54067
popq %rbx
popq %r14
popq %rbp
retq
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::BasicResult<Catch::Clara::Detail::ParseState>::enforceOk() const | void enforceOk() const override {
// Errors shouldn't reach this point, but if they do
// the actual error message will be in m_errorMessage
assert( m_type != ResultType::LogicError );
assert( m_type != ResultType::RuntimeError );
... | cmpl $0x0, 0x8(%rdi)
jne 0x54e4f
retq
pushq %rax
callq 0x15380
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Detail::unique_ptr<Catch::MultiReporter> Catch::Detail::make_unique<Catch::MultiReporter, Catch::Config const*&>(Catch::Config const*&) | unique_ptr<T> make_unique(Args&&... args) {
return unique_ptr<T>(new T(CATCH_FORWARD(args)...));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x40
popq %rdi
callq 0x15640
movq (%rbx), %rcx
andw $0x0, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0x50326(%rip), %rcx # 0xa6380
movq %rcx, (%rax)
andq $0x0, 0x38(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x21(%rax)
movups %xmm0, 0x18(%rax)
movq %rax,... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
std::set<Catch::TestCaseHandle const*, std::less<Catch::TestCaseHandle const*>, std::allocator<Catch::TestCaseHandle const*>> Catch::createShard<std::set<Catch::TestCaseHandle const*, std::less<Catch::TestCaseHandle const*>, std::allocator<Catch::TestCaseHandle const*>>>(std::set<Catch::TestCaseHandle const*, std::less... | Container createShard(Container const& container, std::size_t const shardCount, std::size_t const shardIndex) {
assert(shardCount > shardIndex);
if (shardCount == 1) {
return container;
}
const std::size_t totalTestCount = container.size();
const std::size_t shardS... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x1, %rdx
jne 0x560bb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56516
jmp 0x56115
movq %rcx, %r14
movq %rdx, %rcx
movq 0x18(%r15), %rdi
movq 0x28(%r15), %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
imulq %r14, %rcx
cmpq %r14, %... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::BasicResult<Catch::Clara::ParseResultType>::enforceOk() const | void enforceOk() const override {
// Errors shouldn't reach this point, but if they do
// the actual error message will be in m_errorMessage
assert( m_type != ResultType::LogicError );
assert( m_type != ResultType::RuntimeError );
... | cmpl $0x0, 0x8(%rdi)
jne 0x568f9
retq
pushq %rax
callq 0x15380
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::BasicResult<void>::enforceOk() const | void enforceOk() const override {
// Errors shouldn't reach this point, but if they do
// the actual error message will be in m_errorMessage
assert( m_type != ResultType::LogicError );
assert( m_type != ResultType::RuntimeError );
... | cmpl $0x0, 0x8(%rdi)
jne 0x5692b
retq
pushq %rax
callq 0x15380
nop
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::ParserRefImpl<Catch::Clara::Arg>::ParserRefImpl<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, void>(std::vector<std::__cxx11::basic_string<char, std::char_... | ParserRefImpl( T& ref, StringRef hint ):
m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
m_hint( hint ) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x509ab(%rip), %rax # 0xa7528
movq %rax, (%rdi)
andl $0x0, 0x8(%rdi)
movq %rsp, %rdi
callq 0x56bca
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, 0x10(%r15)
andq $0x0, -0x8(%rdi)
cal... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.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.