name string | code string | asm string | file string |
|---|---|---|---|
mz_zip_reader_extract_file_to_callback | mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip,
const char *pFilename,
mz_file_write_func pCallback,
void *pOpaque, mz_uint flags) {
int file_index = mz_zip... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0xc(%rsp), %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x15fd00
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jge 0x161b59
movl $0x0, 0x34(%rsp)
jmp 0... | /cs248-spring-2018[P]Cardinal3D/CS248/include/CS248/tinyexr.h |
tinyxml2::MemPoolT<72>::Alloc() | virtual void* Alloc() {
if ( !_root ) {
// Need a new block.
Block* block = new Block();
_blockPtrs.Push( block );
for( int i=0; i<COUNT-1; ++i ) {
block->chunk[i].next = &block->chunk[i+1];
}
block->chunk[COUNT-1].next = 0... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x68(%rax)
jne 0x1a70ac
movl $0xfc0, %edi # imm = 0xFC0
callq 0xddc30
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0xfc0, %edx # imm = 0xFC0
callq 0xdd670
movq 0x8(%rsp), %rax
movq 0x10(%rsp... | /cs248-spring-2018[P]Cardinal3D/CS248/include/CS248/tinyxml2.h |
ApprovalTests::FileApprover::verify(ApprovalTests::ApprovalNamer const&, ApprovalTests::ApprovalWriter const&, ApprovalTests::Reporter const&) | void FileApprover::verify(const ApprovalNamer& n,
const ApprovalWriter& s,
const Reporter& r)
{
std::string const approvedPath = n.getApprovedFile(s.getFileExtensionWithDot());
std::string const receivedPath = n.getReceivedFile(s.getFileExt... | subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x108(%rsp), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq 0xc0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq *%rax
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
... | /approvals[P]ApprovalTests/ApprovalTests/core/FileApprover.cpp |
ApprovalTests::FileApprover::reportAfterTryingFrontLoadedReporter(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&, ApprovalTests::Reporter const&) | void
FileApprover::reportAfterTryingFrontLoadedReporter(const std::string& receivedPath,
const std::string& approvedPath,
const Reporter& r)
{
auto tryFirst = FrontLoadedReporterFactory::getFron... | subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1fc50
movq 0x10(%rsp), %rdi
callq 0x15750
movq %rax, 0x18(%rsp)
movq 0xd0(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x11220
jmp 0x15197
movq 0xc8(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0... | /approvals[P]ApprovalTests/ApprovalTests/core/FileApprover.cpp |
ApprovalTests::FileApprover::$_0::operator()() const | void FileApprover::verify(const std::string& receivedPath,
const std::string& approvedPath,
const ApprovalComparator& comparator)
{
if (receivedPath == approvedPath)
{
std::stringstream s;
s << "Identical filenames f... | movq %rdi, -0x8(%rsp)
retq
nopw %cs:(%rax,%rax)
| /approvals[P]ApprovalTests/ApprovalTests/core/FileApprover.cpp |
ApprovalTests::Options::Options(ApprovalTests::Reporter const&) | Options::Options(const Reporter& reporter) : reporter_(reporter)
{
} | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x13e30
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
movq %rdi, 0x10(%rsp)
leaq 0x1c706(%rip), %rsi # 0x327f0
callq 0x13eb0
movq 0x18(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %... | /approvals[P]ApprovalTests/ApprovalTests/core/Options.cpp |
ApprovalTests::Options::fileOptions() const | Options::FileOptions Options::fileOptions() const
{
if (fileOptions_.options_ != nullptr)
{
throw std::logic_error(
"Incorrect assumption: A FileOptions has been re-used");
}
FileOptions copy = fileOptions_.clone();
copy.options_ = this;
re... | subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, (%rax)
je 0x16210
movl $0x10, %edi
callq 0x11280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x7426d(%rip), %rsi # 0x8a444
cal... | /approvals[P]ApprovalTests/ApprovalTests/core/Options.cpp |
ApprovalFileLog::getLogFilePath[abi:cxx11]() | std::string ApprovalFileLog::getLogFilePath()
{
//auto const rootDirectory = ApprovalTests::TestName::getRootDirectory();
auto const rootDirectory = "";
// Note: Need to figure out where the actual root directory is.
std::string const filePath =
rootDirectory + std::string(APPROVAL_TEMP_DIRECTOR... | subq $0xb8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xb0(%rsp)
leaq 0x78ad7(%rip), %rax # 0x8f68a
movq %rax, 0xa8(%rsp)
movb $0x0, 0xa7(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x11930
movq 0x18(%rsp), %rdx
leaq 0x7389b(%rip), %rsi # 0x8a479
leaq 0x60(%rsp), %rd... | /approvals[P]ApprovalTests/ApprovalTests/logs/ApprovalFileLog.cpp |
ApprovalTests::ApprovalTestNamer::getCurrentTest() | TestName& ApprovalTestNamer::getCurrentTest()
{
try
{
return currentTest();
}
catch (const std::runtime_error&)
{
std::string helpMessage = getMisconfiguredMainHelp();
throw std::runtime_error(helpMessage);
}
} | subq $0x48, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x17a70
movq %rax, 0x8(%rsp)
jmp 0x17914
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x179db
movq 0x40(%rsp), %rdi
callq 0x111f0
mov... | /approvals[P]ApprovalTests/ApprovalTests/namers/ApprovalTestNamer.cpp |
ApprovalTests::FileNameSanitizerFactory::defaultSanitizer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | std::string FileNameSanitizerFactory::defaultSanitizer(std::string fileName)
{
std::stringstream result;
for (auto ch : fileName)
{
if (!isForbidden(ch))
{
result << ch;
}
else
{
result << "_";
... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rsi, 0x18(%rsp)
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x11380
movq 0x18(%rsp), %rsi
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x11460
movq %rax, 0x40(%rsp)
movq 0x48(%r... | /approvals[P]ApprovalTests/ApprovalTests/namers/FileNameSanitizerFactory.cpp |
ApprovalTests::HelpMessages::getMisconfiguredBuildHelp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string HelpMessages::getMisconfiguredBuildHelp(const std::string& fileName)
{
std::string helpMessage = R"(* Welcome to Approval Tests.
*
* There seems to be a problem with your build configuration.
* We cannot find the test source file at:
* [fileName]
*
* For details on how to fix this, please visi... | subq $0xb8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
leaq 0x87(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x11930
movq 0x20(%rsp), %rdx
leaq 0x6ff76(%rip), %rsi # 0x8a7e8
leaq 0x88(%rsp), %rdi
callq 0x116e0
jmp 0x1a881
leaq 0x87(%rsp), %rdi
callq 0x11... | /approvals[P]ApprovalTests/ApprovalTests/namers/HelpMessages.cpp |
ApprovalTests::HelpMessages::topAndTailHelpMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string HelpMessages::topAndTailHelpMessage(const std::string& message)
{
const std::string lineBreak =
"**************************************************************"
"***************";
const std::string lineBuffer =
"* ... | subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
leaq 0xe7(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x11930
movq 0x20(%rsp), %rdx
leaq 0x70880(%rip), %rsi # 0x8b262
leaq 0xe8(%rsp), %rdi
callq 0x116e0
jmp 0x1a9f1
leaq... | /approvals[P]ApprovalTests/ApprovalTests/namers/HelpMessages.cpp |
ApprovalTests::HelpMessages::getMisconfiguredMainHelp[abi:cxx11]() | std::string HelpMessages::getMisconfiguredMainHelp()
{
std::string helpMessage = R"(* Welcome to Approval Tests.
*
* You have forgotten to configure your test framework for Approval Tests.
*
* To do this in Catch, add the following to your main.cpp:
*
* #define APPROVALS_CATCH
* #include "ApprovalTe... | subq $0x58, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x11930
movq 0x10(%rsp), %rdx
leaq 0x6fd7c(%rip), %rsi # 0x8a9cc
leaq 0x30(%rsp), %rdi
callq 0x116e0
jmp 0x1ac5c
leaq 0x2f(%rsp), %rdi
callq 0x11560
movq (%rsp), %rdi
leaq ... | /approvals[P]ApprovalTests/ApprovalTests/namers/HelpMessages.cpp |
ApprovalTests::HelpMessages::getUnconfiguredRootDirectory[abi:cxx11]() | std::string HelpMessages::getUnconfiguredRootDirectory()
{
std::string helpMessage = R"(* Hello from Approval Tests.
*
* It looks like your program is calling some code that requires knowledge of
* the location of the main() in your source tree.
*
* To do this, add the following to your main.cpp file:
*
* ... | subq $0x58, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x11930
movq 0x10(%rsp), %rdx
leaq 0x700e3(%rip), %rsi # 0x8ade3
leaq 0x30(%rsp), %rdi
callq 0x116e0
jmp 0x1ad0c
leaq 0x2f(%rsp), %rdi
callq 0x11560
movq (%rsp), %rdi
leaq ... | /approvals[P]ApprovalTests/ApprovalTests/namers/HelpMessages.cpp |
ApprovalTests::HelpMessages::getUnknownEnvVarReporterHelp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char... | std::string
HelpMessages::getUnknownEnvVarReporterHelp(const std::string& envVarName,
const std::string& selected,
const std::vector<std::string>& knowns)
{
std::string helpMessage =
R"(* The enviro... | subq $0x78, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x11930
movq 0x18(%rsp), %rdx
leaq 0x70198(%rip), %rsi # 0x8af58
leaq 0x38(%rsp), %rdi
callq 0x116e0
j... | /approvals[P]ApprovalTests/ApprovalTests/namers/HelpMessages.cpp |
ApprovalTests::HelpMessages::envVarErrorMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::a... | std::string HelpMessages::envVarErrorMessage(const std::string& envVarName,
const std::string& selected,
const std::vector<std::string>& knowns,
std::string& helpMessage)
... | subq $0x388, %rsp # imm = 0x388
movq %rdi, 0x40(%rsp)
movq %rdi, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0x380(%rsp)
movq %rsi, 0x378(%rsp)
movq %rdx, 0x370(%rsp)
movq %rcx, 0x368(%rsp)
movq %r8, 0x360(%rsp)
leaq 0x1d8(%rsp), %rdi
callq 0x11380
movq 0x368(%rsp), %rax
movq %rax, 0x1d0(%rsp)
movq 0x1d0(%rsp), %r... | /approvals[P]ApprovalTests/ApprovalTests/namers/HelpMessages.cpp |
ApprovalTests::HelpMessages::getInvalidEnvVarReporterHelp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char... | std::string
HelpMessages::getInvalidEnvVarReporterHelp(const std::string& envVarName,
const std::string& selected,
const std::vector<std::string>& knowns)
{
std::string helpMessage =
R"(* The enviro... | subq $0x78, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x11930
movq 0x18(%rsp), %rdx
leaq 0x6fd5f(%rip), %rsi # 0x8b0bf
leaq 0x38(%rsp), %rdi
callq 0x116e0
j... | /approvals[P]ApprovalTests/ApprovalTests/namers/HelpMessages.cpp |
ApprovalTests::FirstWorkingReporter::report(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | bool FirstWorkingReporter::report(std::string received, std::string approved) const
{
for (auto& r : reporters)
{
if (r->report(received, approved))
{
return true;
}
}
return false;
} | subq $0xb8, %rsp
movq %rsi, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movq 0xa8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rdi
callq 0x1e4f0
movq %rax, 0x88(%rsp)
movq 0x90(%rsp), %rdi
callq 0x1e520
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), ... | /approvals[P]ApprovalTests/ApprovalTests/reporters/FirstWorkingReporter.cpp |
ApprovalTests::Linux::SublimeMergeReporter::SublimeMergeReporter() | SublimeMergeReporter::SublimeMergeReporter()
: FirstWorkingReporter({new SublimeMergeSnapReporter(),
new SublimeMergeFlatpakReporter(),
new SublimeMergeRepositoryPackageReporter(),
new SublimeMergeDir... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x70, %edi
callq 0x6c710
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x40(%rsp)
callq 0x206b0
jmp 0x20968
movq 0x40(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x70, %edi
callq 0x6c710
movq %r... | /approvals[P]ApprovalTests/ApprovalTests/reporters/LinuxReporters.cpp |
ApprovalTests::Mac::MacDiffReporter::MacDiffReporter() | MacDiffReporter::MacDiffReporter()
: FirstWorkingReporter({
// begin-snippet: mac_diff_reporters
new AraxisMergeReporter(),
new BeyondCompareReporter(),
new DiffMergeReporter(),
new KaleidoscopeReporter(),
... | subq $0x138, %rsp # imm = 0x138
movq %rdi, 0x130(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x98(%rsp)
movl $0x70, %edi
callq 0x6c710
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0xa0(%rsp)
callq 0x212a0
jmp 0x2177e
movq 0xa0(%rsp), %rax
movq %rax, 0xb8(%rsp)
leaq 0xc0(%rsp), %rax
movq %rax, 0x88(%rsp)
movl $0x70... | /approvals[P]ApprovalTests/ApprovalTests/reporters/MacReporters.cpp |
ApprovalTests::Mac::MacDiffReporter::report(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | bool MacDiffReporter::report(std::string received, std::string approved) const
{
if (!SystemUtils::isMacOs())
{
return false;
}
return FirstWorkingReporter::report(received, approved);
} | subq $0x98, %rsp
movq %rsi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x5eeb0
testb $0x1, %al
jne 0x21c29
movb $0x0, 0x97(%rsp)
jmp 0x21cba
movq 0x10(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x11220
movq 0x18(%rsp)... | /approvals[P]ApprovalTests/ApprovalTests/reporters/MacReporters.cpp |
ApprovalTests::ReporterFactory::createMap[abi:cxx11]() | ReporterFactory::Reporters ReporterFactory::createMap()
{
Reporters map;
APPROVAL_TESTS_REGISTER_REPORTER(AutoApproveIfMissingReporter);
APPROVAL_TESTS_REGISTER_REPORTER(AutoApproveReporter);
APPROVAL_TESTS_REGISTER_REPORTER(CIBuildOnlyReporter);
APPROVAL_TESTS_REGISTER_REPO... | subq $0x7a8, %rsp # imm = 0x7A8
movq %rdi, 0x220(%rsp)
movq %rdi, %rax
movq %rax, 0x228(%rsp)
movq %rdi, 0x7a0(%rsp)
movb $0x0, 0x79f(%rsp)
callq 0x2d9c0
leaq 0x777(%rsp), %rdi
movq %rdi, 0x230(%rsp)
callq 0x11930
movq 0x230(%rsp), %rdx
leaq 0x6a1c0(%rip), %rsi # 0x8c2f3
leaq 0x778(%rsp), %rdi
callq 0x11... | /approvals[P]ApprovalTests/ApprovalTests/reporters/ReporterFactory.cpp |
ApprovalTests::ReporterFactory::createReporter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::unique_ptr<Reporter>
ReporterFactory::createReporter(const std::string& reporterName) const
{
auto osPrefix = getOsPrefix();
auto key = findReporterName(osPrefix, reporterName);
if (!key.empty())
{
return map.at(key)();
}
return std::unique_ptr... | subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x21fa0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x80(%rsp), %rcx
leaq 0x40... | /approvals[P]ApprovalTests/ApprovalTests/reporters/ReporterFactory.cpp |
ApprovalTests::ReporterFactory::findReporterName(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&) const | std::string ReporterFactory::findReporterName(const std::string& osPrefix,
const std::string& reporterName) const
{
auto trimmedReporterName = StringUtils::trim(reporterName);
trimmedReporterName = StringUtils::toLower(trimmedReporterName);
... | subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, 0x70(%rsp)
movq %rdi, %rax
movq %rax, 0x78(%rsp)
movq %rdi, 0x2e0(%rsp)
movq %rsi, 0x2d8(%rsp)
movq %rdx, 0x2d0(%rsp)
movq %rcx, 0x2c8(%rsp)
movq 0x2d8(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x2c8(%rsp), %rsi
leaq 0x288(%rsp), %rdi
movq %rdi, 0x88(%rsp)
callq 0x1122... | /approvals[P]ApprovalTests/ApprovalTests/reporters/ReporterFactory.cpp |
ApprovalTests::TextDiffReporter::report(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | bool TextDiffReporter::report(std::string received, std::string approved) const
{
stream_ << "Comparing files:" << std::endl;
stream_ << "received: " << received << std::endl;
stream_ << "approved: " << approved << std::endl;
const bool result = m_reporter->report(received, approved)... | subq $0xa8, %rsp
movq %rsi, 0x20(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rax), %rdi
leaq 0x5bb06(%rip), %rsi # 0x8c6c7
callq 0x114e0
movq %rax, %rdi
movq 0x95380(%rip), %rsi # 0xc5f50
movq %rsi, 0x10(%rs... | /approvals[P]ApprovalTests/ApprovalTests/reporters/TextDiffReporter.cpp |
ApprovalTests::Windows::TortoiseDiffReporter::TortoiseDiffReporter() | TortoiseDiffReporter::TortoiseDiffReporter()
: FirstWorkingReporter(
{new TortoiseTextDiffReporter(), new TortoiseImageDiffReporter()})
{
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x70, %edi
callq 0x6c710
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
callq 0x317d0
jmp 0x3187f
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x70, %edi
callq 0x6c710
movq %ra... | /approvals[P]ApprovalTests/ApprovalTests/reporters/WindowsReporters.cpp |
ApprovalTests::Windows::TortoiseGitDiffReporter::TortoiseGitDiffReporter() | TortoiseGitDiffReporter::TortoiseGitDiffReporter()
: FirstWorkingReporter(
{new TortoiseGitTextDiffReporter(), new TortoiseGitImageDiffReporter()})
{
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x70, %edi
callq 0x6c710
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
callq 0x319b0
jmp 0x31adf
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x70, %edi
callq 0x6c710
movq %ra... | /approvals[P]ApprovalTests/ApprovalTests/reporters/WindowsReporters.cpp |
ApprovalTests::StringUtils::rightTrim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | APPROVAL_TESTS_NO_DISCARD
std::string StringUtils::rightTrim(std::string s)
{
s.erase(std::find_if(s.rbegin(),
s.rend(),
[](unsigned char ch) { return !std::isspace(ch); })
.base(),
s.end());
return s;
... | subq $0x78, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x11900
movq 0x10(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x11630
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x5e000
leaq... | /approvals[P]ApprovalTests/ApprovalTests/utilities/StringUtils.cpp |
ApprovalTests::SystemUtils::checkFilenameCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string SystemUtils::checkFilenameCase(const std::string& fullPath)
{
if (!isWindowsOs() || !FileUtils::fileExists(fullPath))
{
return fullPath;
}
#ifdef _WIN32
_finddata_t findFileData;
auto hFind = _findfirst(fullPath.c_str(), &findFileData);
if (h... | subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
callq 0x5ee90
testb $0x1, %al
jne 0x5ef86
jmp 0x5ef94
movq 0x18(%rsp), %rdi
callq 0x5d1d0
testb $0x1, %al
jne 0x5efa5
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11220
jmp 0x5efb4
movq 0x8(%rsp... | /approvals[P]ApprovalTests/ApprovalTests/utilities/SystemUtils.cpp |
ApprovalTests::SystemUtils::safeGetEnvForWindows[abi:cxx11](char const*) | std::string SystemUtils::safeGetEnvForWindows(const char* name)
{
APPROVAL_TESTS_UNUSED(name);
#ifdef _WIN32
// We use getenv_s on Windows, as use of getenv there gives:
// warning C4996: 'getenv': This function or variable may be unsafe. Consider using _dupenv_s instead.
// ... | subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
jmp 0x5efdd
movq 0x8(%rsp), %rdi
callq 0x116f0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| /approvals[P]ApprovalTests/ApprovalTests/utilities/SystemUtils.cpp |
ApprovalTests::SystemUtils::safeGetEnvForNonWindows[abi:cxx11](char const*) | std::string SystemUtils::safeGetEnvForNonWindows(const char* name)
{
APPROVAL_TESTS_UNUSED(name);
char* p = nullptr;
#ifndef _WIN32
p = getenv(name);
#endif
return (p != nullptr) ? p : std::string();
} | subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
jmp 0x5f01d
movq $0x0, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x11650
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movb $0x0, 0x3e(%rsp)
cmpq $0x0, %rax
je 0x5f07b
movq 0x40(%rsp), %rax
movq %rax, 0x8... | /approvals[P]ApprovalTests/ApprovalTests/utilities/SystemUtils.cpp |
ApprovalTests::SystemUtils::getMachineName[abi:cxx11]() | std::string SystemUtils::getMachineName()
{
auto name = safeGetEnv("COMPUTERNAME");
if (!name.empty())
{
return name;
}
name = safeGetEnv("HOSTNAME");
if (!name.empty())
{
return name;
}
return "Unknown Computer";
... | subq $0x78, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x2eb5a(%rip), %rsi # 0x8dc9c
callq 0x5f0d0
leaq 0x50(%rsp), %rdi
callq 0x11880
testb $0x1, %al
jne 0x5f171
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x112e0
movl $0x1, 0x4c(%rsp)
jmp ... | /approvals[P]ApprovalTests/ApprovalTests/utilities/SystemUtils.cpp |
ApprovalTests::SystemUtils::makeDirectoryForWindows(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SystemUtils::makeDirectoryForWindows(const std::string& directory)
{
APPROVAL_TESTS_UNUSED(directory);
#ifdef _WIN32
int nError = _mkdir(directory.c_str());
if (nError != 0)
{
std::string helpMessage =
std::string("Unable to create directory: ") + dir... | movq %rdi, -0x8(%rsp)
retq
nopw %cs:(%rax,%rax)
| /approvals[P]ApprovalTests/ApprovalTests/utilities/SystemUtils.cpp |
ApprovalTests::SystemUtils::makeDirectoryForNonWindows(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SystemUtils::makeDirectoryForNonWindows(const std::string& directory)
{
APPROVAL_TESTS_UNUSED(directory);
#ifndef _WIN32
mode_t nMode = 0733; // UNIX style permissions
int nError = mkdir(directory.c_str(), nMode);
if (nError != 0)
{
std::string helpMessage =
... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl $0x1db, 0x6c(%rsp) # imm = 0x1DB
movq 0x70(%rsp), %rdi
callq 0x11200
movq %rax, %rdi
movl 0x6c(%rsp), %esi
callq 0x11260
movl %eax, 0x68(%rsp)
cmpl $0x0, 0x68(%rsp)
je 0x5f387
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x11930
movq 0x8(%rsp), %rdx
leaq 0x2ea12(%rip... | /approvals[P]ApprovalTests/ApprovalTests/utilities/SystemUtils.cpp |
ApprovalTests::SystemUtils::runSystemCommandOrThrow(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | void SystemUtils::runSystemCommandOrThrow(const std::string& command,
bool allowNonZeroExitCodes)
{
int exitCode = system(command.c_str());
if (!allowNonZeroExitCodes && exitCode != 0)
{
throw std::runtime_error(command + ": failed w... | subq $0x98, %rsp
movb %sil, %al
movq %rdi, 0x90(%rsp)
andb $0x1, %al
movb %al, 0x8f(%rsp)
movq 0x90(%rsp), %rdi
callq 0x11200
movq %rax, %rdi
callq 0x11450
movl %eax, 0x88(%rsp)
testb $0x1, 0x8f(%rsp)
jne 0x5f59f
cmpl $0x0, 0x88(%rsp)
je 0x5f59f
movb $0x1, 0x17(%rsp)
movl $0x10, %edi
callq 0x11280
movq %rax, 0x8(%rsp)
... | /approvals[P]ApprovalTests/ApprovalTests/utilities/SystemUtils.cpp |
ApprovalTests::StringWriter::write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | void StringWriter::write(std::string path) const
{
std::ofstream out(path.c_str(), std::ofstream::out);
if (!out)
{
throw std::runtime_error("Unable to write file: " + path);
}
this->Write(out);
out.close();
} | subq $0x268, %rsp # imm = 0x268
movq %rsi, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rax, 0x260(%rsp)
movq %rdi, 0x258(%rsp)
movq 0x260(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x11200
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
movl $0x10, %edx
callq 0x11570
movq 0x58(%rsp), %rax
m... | /approvals[P]ApprovalTests/ApprovalTests/writers/StringWriter.cpp |
ApprovalTests::ComparatorFactory::registerComparator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<ApprovalTests::ApprovalComparator>) | ComparatorDisposer
ComparatorFactory::registerComparator(const std::string& extensionWithDot,
std::shared_ptr<ApprovalComparator> comparator)
{
return ComparatorDisposer(comparators(),
extensionWithDot,
... | subq $0x88, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
callq 0x5f890
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rsi
movq %rsi, 0x28(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x5f9c0
movq 0x10(%rsp), %... | /approvals[P]ApprovalTests/ApprovalTests/comparators/ComparatorFactory.cpp |
ApprovalTests::TextFileComparator::contentsAreEquivalent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | bool TextFileComparator::contentsAreEquivalent(std::string receivedPath,
std::string approvedPath) const
{
std::ifstream astream(approvedPath.c_str(), std::ios::binary | std::ifstream::in);
std::ifstream rstream(receivedPath.c_str(), std::ios::binar... | subq $0x488, %rsp # imm = 0x488
movq %rdx, 0x10(%rsp)
movq %rdi, %rax
movq 0x10(%rsp), %rdi
movq %rsi, 0x20(%rsp)
movq %rax, 0x478(%rsp)
movq %rsi, 0x470(%rsp)
movq %rdi, 0x468(%rsp)
callq 0x11200
movq %rax, 0x18(%rsp)
movl $0x4, %edi
movl %edi, 0x28(%rsp)
movl $0x8, %esi
movl %esi, 0x2c(%rsp)
callq 0x5da90
... | /approvals[P]ApprovalTests/ApprovalTests/comparators/TextFileComparator.cpp |
ApprovalTests::ApprovalMismatchException::format(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string ApprovalMismatchException::format(const std::string& received,
const std::string& approved)
{
std::stringstream s;
s << "Failed Approval: \n"
<< "Received does not match approved \n"
<< "Received : \"" << received << "... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq %rdx, 0x1f0(%rsp)
movq %rcx, 0x1e8(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x11380
leaq 0x70(%rsp), %rdi
leaq 0x2cec4(%rip), %rsi # 0x8ddee
callq 0x114e0
movq %rax, 0x4... | /approvals[P]ApprovalTests/ApprovalTests/core/ApprovalException.cpp |
ApprovalTests::ApprovalMissingException::format(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string ApprovalMissingException::format(const std::string& file)
{
std::stringstream s;
s << "Failed Approval: \n"
<< "Approval File Not Found \n"
<< "File: \"" << file << '"';
return s.str();
} | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x11380
leaq 0x58(%rsp), %rdi
leaq 0x2ccdc(%rip), %rsi # 0x8ddee
callq 0x114e0
movq %rax, 0x30(%rsp)
jmp 0x6111e
mov... | /approvals[P]ApprovalTests/ApprovalTests/core/ApprovalException.cpp |
ApprovalTests::AutoApproveIfMissingReporter::report(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | bool AutoApproveIfMissingReporter::report(std::string received,
std::string approved) const
{
if (FileUtils::fileExists(approved))
{
return false;
}
return AutoApproveReporter().report(received, approved);
} | subq $0x98, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rsi, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq %rax, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdi, 0x78(%rsp)
callq 0x5d1d0
testb $0x1, %al
jne 0x6186e
jmp 0x6187b
movb $0x0, 0x97(%rsp)
jmp 0x61945
movq $0x0, 0x70(%rsp)
leaq 0x70(%rsp), %rdi
cal... | /approvals[P]ApprovalTests/ApprovalTests/reporters/AutoApproveIfMissingReporter.cpp |
ApprovalTests::CIBuildOnlyReporter::report(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | bool CIBuildOnlyReporter::report(std::string received, std::string approved) const
{
if (!isRunningUnderCI())
{
return false;
}
m_reporter->report(received, approved);
// Return true regardless of whether our report succeeded or not,
// so that no later re... | subq $0x98, %rsp
movq %rsi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x61bb0
testb $0x1, %al
jne 0x61ae9
movb $0x0, 0x97(%rsp)
jmp 0x61b88
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0x15750
movq 0x10(%rsp), %rsi... | /approvals[P]ApprovalTests/ApprovalTests/reporters/CIBuildOnlyReporter.cpp |
ApprovalTests::ClipboardReporter::getCommandLineFor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::string ClipboardReporter::getCommandLineFor(const std::string& received,
const std::string& approved,
bool isWindows)
{
if (isWindows)
{
return std::string("move /Y ") + "\"" + ... | subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, 0x18(%rsp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, 0x20(%rsp)
movq %rdi, 0x1a0(%rsp)
movq %rsi, 0x198(%rsp)
movq %rdx, 0x190(%rsp)
andb $0x1, %al
movb %al, 0x18f(%rsp)
testb $0x1, 0x18f(%rsp)
je 0x61fa5
leaq 0xe7(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x11930
movq... | /approvals[P]ApprovalTests/ApprovalTests/reporters/ClipboardReporter.cpp |
ApprovalTests::CommandReporter::exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool CommandReporter::exists(const std::string& command)
{
bool foundByWhich = false;
if (!SystemUtils::isWindowsOs())
{
std::string which = "which " + command + " > /dev/null 2>&1";
int result = system(which.c_str());
foundByWhich = (result == 0);
... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movb $0x0, 0x6f(%rsp)
callq 0x5ee90
testb $0x1, %al
jne 0x62c86
movq 0x70(%rsp), %rdx
leaq 0x2b443(%rip), %rsi # 0x8e02a
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5d960
movq 0x10(%rsp), %rsi
leaq 0x2b42f(%rip), %rdx # 0x8e031
leaq 0x48(%rsp), %rdi
callq 0x16e20
j... | /approvals[P]ApprovalTests/ApprovalTests/reporters/CommandReporter.cpp |
ApprovalTests::CommandReporter::report(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | bool CommandReporter::report(std::string received, std::string approved) const
{
if (!exists(cmd))
{
return false;
}
FileUtils::ensureFileExists(approved);
return l->launch(assembleFullCommand(received, approved));
} | subq $0x88, %rsp
movq %rsi, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x8, %rdi
callq 0x62bc0
testb $0x1, %al
jne 0x62d01
movb $0x0, 0x87(%rsp)
jmp 0x62d7e
movq 0x28(%rsp), %rdi
callq 0x5d300
movq 0x30(%rsp), %rsi... | /approvals[P]ApprovalTests/ApprovalTests/reporters/CommandReporter.cpp |
ApprovalTests::DiffInfo::getProgramFileLocations[abi:cxx11]() | std::vector<std::string> DiffInfo::getProgramFileLocations()
{
std::vector<std::string> possibleWindowsPaths;
const std::vector<const char*> envVars = {
"ProgramFiles", "ProgramW6432", "ProgramFiles(x86)"};
for (const auto& envVar : envVars)
{
std::string env... | subq $0xc8, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xc0(%rsp)
movb $0x0, 0xbf(%rsp)
callq 0x12c70
movq 0x5e269(%rip), %rax # 0xc3ec8
movq %rax, 0x80(%rsp)
movups 0x5e24a(%rip), %xmm0 # 0xc3eb8
movaps %xmm0, 0x70(%rsp)
leaq 0x70(%rsp), %rax
movq %rax, 0x90(%rsp)
movq $0x3, 0x98(%rs... | /approvals[P]ApprovalTests/ApprovalTests/reporters/DiffInfo.cpp |
ApprovalTests::DiffInfo::getProgramForOs[abi:cxx11]() const | std::string DiffInfo::getProgramForOs() const
{
std::string result = program;
if (result.rfind(programFileTemplate(), 0) == 0)
{
std::vector<std::string> possibleWindowsPaths = getProgramFileLocations();
for (const auto& path : possibleWindowsPaths)
{
... | subq $0x108, %rsp # imm = 0x108
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq 0xf8(%rsp), %rsi
leaq 0xd8(%rsp), %rdi
callq 0x11220
leaq 0xb8(%rsp), %rdi
callq 0x65a00
jmp 0x65e68
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
xorl %eax, %eax
movl %... | /approvals[P]ApprovalTests/ApprovalTests/reporters/DiffInfo.cpp |
ApprovalTests::ComparatorDisposer::ComparatorDisposer(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<ApprovalTests::ApprovalComparator>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cx... | ComparatorDisposer::ComparatorDisposer(
ComparatorContainer& comparators_,
const std::string& extensionWithDot,
std::shared_ptr<ApprovalTests::ApprovalComparator> previousComparator_,
std::shared_ptr<ApprovalTests::ApprovalComparator> newComparator)
: comparators(comparators_)
... | subq $0x68, %rsp
movq %rcx, 0x18(%rsp)
movq %r8, (%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movb $0x1, (%rdi)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, 0x8(%rsp)
movq 0x50(%r... | /approvals[P]ApprovalTests/ApprovalTests/comparators/ComparatorDisposer.cpp |
MemoryLeakWarningPlugin::turnOffNewDeleteOverloads() | void MemoryLeakWarningPlugin::turnOffNewDeleteOverloads()
{
#if CPPUTEST_USE_MEM_LEAK_DETECTION
operator_new_fptr = normal_operator_new;
operator_new_nothrow_fptr = normal_operator_new_nothrow;
operator_new_debug_fptr = normal_operator_new_debug;
operator_new_array_fptr = normal_operator_new_array;
... | leaq 0x99(%rip), %rax # 0x6ca10
movq %rax, 0x5a00a(%rip) # 0xc6988
leaq 0xeb(%rip), %rax # 0x6ca70
movq %rax, 0x5a02c(%rip) # 0xc69b8
leaq 0x11d(%rip), %rax # 0x6cab0
movq %rax, 0x59ff6(%rip) # 0xc6990
leaq 0x17f(%rip), %rax # 0x6cb20
movq %rax, 0x59ff8(%rip) # 0xc69a0
leaq 0x1... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/MemoryLeakWarningPlugin.cpp |
threadsafe_mem_leak_operator_new_array(unsigned long) | UT_THROW(std::bad_alloc)
{
MemLeakScopedMutex lock;
void* memory = MemoryLeakWarningPlugin::getGlobalDetector()->allocMemory(getCurrentNewArrayAllocator(), size);
UT_THROW_BAD_ALLOC_WHEN_NULL(memory);
return memory;
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x6e350
callq 0x6dd00
movq %rax, 0x28(%rsp)
jmp 0x6d56f
callq 0x73e30
movq %rax, 0x20(%rsp)
jmp 0x6d57b
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdi
movq 0x50(%rsp), %rdx
xorl %ecx, %ecx
callq 0x80000
movq %rax, 0x18(%rsp)
jmp 0x6d598
movq 0x18(%rsp), %r... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/MemoryLeakWarningPlugin.cpp |
threadsafe_mem_leak_operator_delete(void*) | static void threadsafe_mem_leak_operator_delete (void* mem) UT_NOTHROW
{
MemLeakScopedMutex lock;
MemoryLeakWarningPlugin::getGlobalDetector()->invalidateMemory((char*) mem);
MemoryLeakWarningPlugin::getGlobalDetector()->deallocMemory(getCurrentNewAllocator(), (char*) mem);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x6e350
jmp 0x6d795
callq 0x6dd00
movq %rax, 0x10(%rsp)
jmp 0x6d7a1
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7fd40
jmp 0x6d7b2
callq 0x6dd00
movq %rax, 0x8(%rsp)
jmp 0x6d7be
callq 0x73d40
movq %rax, (%rsp)
jmp 0x6d7c9
movq (%rsp), %rsi
movq 0... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/MemoryLeakWarningPlugin.cpp |
threadsafe_mem_leak_operator_delete_array(void*) | static void threadsafe_mem_leak_operator_delete_array (void* mem) UT_NOTHROW
{
MemLeakScopedMutex lock;
MemoryLeakWarningPlugin::getGlobalDetector()->invalidateMemory((char*) mem);
MemoryLeakWarningPlugin::getGlobalDetector()->deallocMemory(getCurrentNewArrayAllocator(), (char*) mem);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x6e350
jmp 0x6d815
callq 0x6dd00
movq %rax, 0x10(%rsp)
jmp 0x6d821
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7fd40
jmp 0x6d832
callq 0x6dd00
movq %rax, 0x8(%rsp)
jmp 0x6d83e
callq 0x73e30
movq %rax, (%rsp)
jmp 0x6d849
movq (%rsp), %rsi
movq 0... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/MemoryLeakWarningPlugin.cpp |
MemoryLeakWarningPlugin::saveAndDisableNewDeleteOverloads() | void MemoryLeakWarningPlugin::saveAndDisableNewDeleteOverloads()
{
#if CPPUTEST_USE_MEM_LEAK_DETECTION
if (++save_counter > 1) return;
saved_operator_new_fptr = operator_new_fptr;
saved_operator_new_nothrow_fptr = operator_new_nothrow_fptr;
saved_operator_new_debug_fptr = operator_new_debug_fptr;
sa... | pushq %rax
movl 0x59361(%rip), %eax # 0xc6e28
addl $0x1, %eax
movl %eax, 0x59358(%rip) # 0xc6e28
cmpl $0x1, %eax
jle 0x6dada
jmp 0x6db79
movq 0x58ea7(%rip), %rax # 0xc6988
movq %rax, 0x58ee0(%rip) # 0xc69c8
movq 0x58ec9(%rip), %rax # 0xc69b8
movq %rax, 0x58eda(%rip) # 0xc69d0
movq 0x58e93(%rip),... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/MemoryLeakWarningPlugin.cpp |
MemoryLeakWarningPlugin::getGlobalDetector() | MemoryLeakDetector* MemoryLeakWarningPlugin::getGlobalDetector()
{
if (globalDetector == NULLPTR) {
saveAndDisableNewDeleteOverloads();
globalReporter = new MemoryLeakWarningReporter;
globalDetector = new MemoryLeakDetector(globalReporter);
restoreNewDeleteOverloads();
}
re... | subq $0x28, %rsp
cmpq $0x0, 0x59154(%rip) # 0xc6e60
jne 0x6dd8b
callq 0x6dac0
movl $0x8, %edi
callq 0x6c710
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
callq 0x6e2e0
movq 0x8(%rsp), %rax
movq %rax, 0x59132(%rip) # 0xc6e68
movl $0x1298, %edi # imm = 0x1298
callq 0x6c710
movq %rax, %rdi
movq %rdi, %rax
movq %r... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/MemoryLeakWarningPlugin.cpp |
MemoryLeakWarningPlugin::destroyGlobalDetector() | void MemoryLeakWarningPlugin::destroyGlobalDetector()
{
turnOffNewDeleteOverloads();
delete globalDetector;
delete globalReporter;
globalDetector = NULLPTR;
} | subq $0x18, %rsp
callq 0x6c970
movq 0x59040(%rip), %rax # 0xc6e60
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x6de36
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x5902b(%rip), %rax # 0xc6e68
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x6de53
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
m... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/MemoryLeakWarningPlugin.cpp |
MemoryLeakWarningPlugin::MemoryLeakWarningPlugin(SimpleString const&, MemoryLeakDetector*) | MemoryLeakWarningPlugin::MemoryLeakWarningPlugin(const SimpleString& name, MemoryLeakDetector* localDetector) :
TestPlugin(name), ignoreAllWarnings_(false), destroyGlobalDetectorAndTurnOfMemoryLeakDetectionInDestructor_(false), expectedLeaks_(0)
{
if (firstPlugin_ == NULLPTR) firstPlugin_ = this;
if (local... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x28(%rsp), %rsi
callq 0x80710
movq 0x8(%rsp), %rax
leaq 0x56085(%rip), %rcx # 0xc3f78
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, 0x30(%rax)
movb $0x0, 0x31(%rax)
movq $0x0, 0x38(%ra... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/MemoryLeakWarningPlugin.cpp |
MemoryLeakWarningPlugin::postTestAction(UtestShell&, TestResult&) | void MemoryLeakWarningPlugin::postTestAction(UtestShell& test, TestResult& result)
{
memLeakDetector_->stopChecking();
size_t leaks = memLeakDetector_->totalMemoryLeaks(mem_leak_period_checking);
if (!ignoreAllWarnings_ && expectedLeaks_ != leaks && failureCount_ == result.getFailureCount()) {
if(M... | subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x28(%rax), %rdi
callq 0x7f820
movq 0x38(%rsp), %rax
movq 0x28(%rax), %rdi
movl $0x3, %esi
callq 0x80670
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0xd8(%rsp)
testb $0x1, 0x30(%rax)
... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/MemoryLeakWarningPlugin.cpp |
TestRegistry::listTestGroupAndCaseNames(TestResult&) | void TestRegistry::listTestGroupAndCaseNames(TestResult& result)
{
SimpleString groupAndNameList;
for (UtestShell *test = tests_; test != NULLPTR; test = test->getNext()) {
if (testShouldRun(test, result)) {
SimpleString groupAndName;
groupAndName += "#";
groupAndNam... | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0x209d7(%rip), %rsi # 0x8f68a
callq 0x71300
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xa0(%rsp)
cmpq $0x0, 0xa0(%rsp)
je 0x6eed5
movq 0x38(%rsp), %rdi
movq 0xa0(%rsp), %rs... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestRegistry.cpp |
CommandLineTestRunner::parseArguments(TestPlugin*) | bool CommandLineTestRunner::parseArguments(TestPlugin* plugin)
{
if (!arguments_->parse(plugin)) {
output_ = createConsoleOutput();
output_->print((arguments_->needHelp()) ? arguments_->help() : arguments_->usage());
return false;
}
if (arguments_->isJUnitOutput()) {
output_= createJUnitOutput(ar... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x861c0
testb $0x1, %al
jne 0x6fcdb
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%ra... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/CommandLineTestRunner.cpp |
CommandLineTestRunner::initializeTestRun() | void CommandLineTestRunner::initializeTestRun()
{
registry_->setGroupFilters(arguments_->getGroupFilters());
registry_->setNameFilters(arguments_->getNameFilters());
if (arguments_->isVerbose()) output_->verbose(TestOutput::level_verbose);
if (arguments_->isVeryVerbose()) output_->verbose(TestOutput::l... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rdi
callq 0x88bc0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x58(%rax)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rax), %r... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/CommandLineTestRunner.cpp |
CommandLineTestRunner::createJUnitOutput(SimpleString const&) | TestOutput* CommandLineTestRunner::createJUnitOutput(const SimpleString& packageName)
{
JUnitTestOutput* junitOutput = new JUnitTestOutput;
if (junitOutput != NULLPTR) {
junitOutput->setPackageName(packageName);
}
return junitOutput;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
leaq 0x1e719(%rip), %rsi # 0x8e9fe
movl $0x28, %edi
movl $0x9a, %edx
callq 0x6c730
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x76980
jmp 0x70306
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x7034f
movq 0x20(%rsp), ... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/CommandLineTestRunner.cpp |
CommandLineTestRunner::createCompositeOutput(TestOutput*, TestOutput*) | TestOutput* CommandLineTestRunner::createCompositeOutput(TestOutput* outputOne, TestOutput* outputTwo)
{
CompositeTestOutput* composite = new CompositeTestOutput;
composite->setOutputOne(outputOne);
composite->setOutputTwo(outputTwo);
return composite;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x1e604(%rip), %rsi # 0x8e9fe
movl $0x30, %edi
movl $0xa8, %edx
callq 0x6c730
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
callq 0x7d9e0
jmp 0x7041a
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%r... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/CommandLineTestRunner.cpp |
GlobalSimpleStringMemoryAccountant::~GlobalSimpleStringMemoryAccountant() | GlobalSimpleStringMemoryAccountant::~GlobalSimpleStringMemoryAccountant()
{
restoreAllocator();
delete accountant_;
delete allocator_;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x70730
jmp 0x706ca
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x706f7
movq 0x10(%rsp), %rdi
callq 0x74e80
movq 0x10(%rsp), %rdi
movl $0x18, %esi
callq 0x6c7b0
movq 0x18(%rsp), %rax
movq (%r... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/SimpleString.cpp |
GlobalSimpleStringMemoryAccountant::start() | void GlobalSimpleStringMemoryAccountant::start()
{
if (allocator_ != NULLPTR)
return;
allocator_ = new AccountingTestMemoryAllocator(*accountant_, SimpleString::getStringAllocator());
SimpleString::setStringAllocator(allocator_);
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, (%rax)
je 0x707bb
jmp 0x7081b
leaq 0x1e326(%rip), %rsi # 0x8eae8
movl $0x40, %edi
movl $0x4f, %edx
callq 0x6c730
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x705... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/SimpleString.cpp |
SimpleString::AtoI(char const*) | int SimpleString::AtoI(const char* str)
{
while (isSpace(*str)) str++;
char first_char = *str;
if (first_char == '-' || first_char == '+') str++;
int result = 0;
for(; isDigit(*str); str++)
{
result *= 10;
result += *str - '0';
}
return (first_char == '-') ? -result : ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %edi
callq 0x70b30
testb $0x1, %al
jne 0x70bdc
jmp 0x70bec
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x70bc9
movq 0x10(%rsp), %rax
movb (%rax), %al
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x2d, %eax
je 0x70c0b
mov... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/SimpleString.cpp |
SimpleString::StrStr(char const*, char const*) | const char* SimpleString::StrStr(const char* s1, const char* s2)
{
if(!*s2) return s1;
for (; *s1; s1++)
if (StrNCmp(s1, s2, StrLen(s2)) == 0)
return s1;
return NULLPTR;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x70eb4
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x70f1a
jmp 0x70eb6
movq 0x18(%rsp), %rax
cmpb $0x0, (%rax)
je 0x70f11
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq ... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/SimpleString.cpp |
SimpleString::lowerCase() const | SimpleString SimpleString::lowerCase() const
{
SimpleString str(*this);
size_t str_size = str.size();
for (size_t i = 0; i < str_size; i++)
str.buffer_[i] = ToLower(str.getBuffer()[i]);
return str;
} | subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rsi
movb $0x0, 0x47(%rsp)
callq 0x71410
movq 0x10(%rsp), %rdi
callq 0x71280
movq %rax, 0x18(%rsp)
jmp 0x715ab
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq $0x0, 0x20(%rsp)
movq 0... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/SimpleString.cpp |
SimpleString::split(SimpleString const&, SimpleStringCollection&) const | void SimpleString::split(const SimpleString& delimiter, SimpleStringCollection& col) const
{
size_t num = count(delimiter);
size_t extraEndToken = (endsWith(delimiter)) ? 0 : 1U;
col.allocate(num + extraEndToken);
const char* str = getBuffer();
const char* prev;
for (size_t i = 0; i < num; ++i)... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x98(%rsp), %rsi
callq 0x717a0
movq 0x20(%rsp), %rdi
movq %rax, 0x88(%rsp)
movq 0x98(%rsp), %rsi
callq 0x716f0
movb %al, %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/SimpleString.cpp |
SimpleString::operator+=(char const*) | SimpleString& SimpleString::operator+=(const char* rhs)
{
size_t originalSize = this->size();
size_t additionalStringSize = StrLen(rhs) + 1;
size_t sizeOfNewString = originalSize + additionalStringSize;
char* tbuffer = copyToNewBuffer(this->getBuffer(), sizeOfNewString);
StrNCpy(tbuffer + originalSi... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x71280
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x70d00
movq (%rsp), %rdi
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x712f0
movq %rax, ... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/SimpleString.cpp |
SimpleString::padStringsToSameLength(SimpleString&, SimpleString&, char) | void SimpleString::padStringsToSameLength(SimpleString& str1, SimpleString& str2, char padCharacter)
{
if (str1.size() > str2.size()) {
padStringsToSameLength(str2, str1, padCharacter);
return;
}
char pad[2];
pad[0] = padCharacter;
pad[1] = 0;
str1 = SimpleString(pad, str2.size(... | subq $0x68, %rsp
movb %dl, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb %al, 0x57(%rsp)
movq 0x60(%rsp), %rdi
callq 0x71280
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
callq 0x71280
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jbe 0x72370
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
movsbl 0x57(%rsp), %... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/SimpleString.cpp |
SimpleString::subStringFromTill(char, char) const | SimpleString SimpleString::subStringFromTill(char startChar, char lastExcludedChar) const
{
size_t beginPos = find(startChar);
if (beginPos == npos) return "";
size_t endPos = findFrom(beginPos, lastExcludedChar);
if (endPos == npos) return subString(beginPos);
return subString(beginPos, endPos - ... | subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movb %cl, %al
movb %dl, %cl
movq %rdi, %rdx
movq %rdx, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb %cl, 0x37(%rsp)
movb %al, 0x36(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movsbl 0x37(%rsp), %esi
callq 0x724a0
movq %rax, 0x28(%rsp)
cmpq $-0x1, 0x28(%rsp)
jne... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/SimpleString.cpp |
SimpleString::copyToBuffer(char*, unsigned long) const | void SimpleString::copyToBuffer(char* bufferToCopy, size_t bufferSize) const
{
if (bufferToCopy == NULLPTR || bufferSize == 0) return;
size_t sizeToCopy = (bufferSize-1 < size()) ? (bufferSize-1) : size();
StrNCpy(bufferToCopy, getBuffer(), sizeToCopy);
bufferToCopy[sizeToCopy] = '\0';
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x7264d
cmpq $0x0, 0x30(%rsp)
jne 0x72652
jmp 0x726d4
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x18(%rsp)
callq 0x71280
movq %rax, %rcx
mo... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/SimpleString.cpp |
HexStringFrom(signed char) | SimpleString HexStringFrom(signed char value)
{
SimpleString result = StringFromFormat("%x", value);
if(value < 0) {
size_t size = result.size();
result = result.subString(size-(CPPUTEST_CHAR_BIT/4));
}
return result;
} | subq $0x48, %rsp
movq %rdi, (%rsp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movb %al, 0x3f(%rsp)
movb $0x0, 0x3e(%rsp)
movsbl 0x3f(%rsp), %edx
leaq 0x1c01d(%rip), %rsi # 0x8ec1a
movb $0x0, %al
callq 0x72730
movsbl 0x3f(%rsp), %eax
cmpl $0x0, %eax
jge 0x72c7b
movq (%rsp), %rdi
callq ... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/SimpleString.cpp |
StringFrom(double, int) | SimpleString StringFrom(double value, int precision)
{
if (PlatformSpecificIsNan(value))
return "Nan - Not a number";
else if (PlatformSpecificIsInf(value))
return "Inf - Infinity";
else
return StringFromFormat("%.*g", precision, value);
} | subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movl %esi, 0x14(%rsp)
leaq 0x537fa(%rip), %rax # 0xc6af0
movq (%rax), %rax
movsd 0x18(%rsp), %xmm0
callq *%rax
cmpl $0x0, %eax
je 0x73318
movq (%rsp), %rdi
leaq 0x1b91f(%rip), %rsi # 0x8ec30
cal... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/SimpleString.cpp |
StringFromBinary(unsigned char const*, unsigned long) | SimpleString StringFromBinary(const unsigned char* value, size_t size)
{
SimpleString result;
for (size_t i = 0; i < size; i++) {
result += StringFromFormat("%02X ", value[i]);
}
result = result.subString(0, result.size() - 1);
return result;
} | subq $0x68, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movb $0x0, 0x4f(%rsp)
leaq 0x1bfcf(%rip), %rsi # 0x8f68a
callq 0x71300
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x7374f
movq 0x58(%rsp), %rax
movq 0x... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/SimpleString.cpp |
checkedMalloc(unsigned long) | static char* checkedMalloc(size_t size)
{
char* mem = (char*) PlatformSpecificMalloc(size);
if (mem == NULLPTR)
FAIL("malloc returned null pointer");
return mem;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
leaq 0x52830(%rip), %rax # 0xc6ab0
movq (%rax), %rax
movq 0x30(%rsp), %rdi
callq *%rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x7430a
jmp 0x74299
callq 0x815a0
movq %rax, (%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x137d0
movq (%rsp)... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestMemoryAllocator.cpp |
FailableMemoryAllocator::checkAllFailedAllocsWereDone() | void FailableMemoryAllocator::checkAllFailedAllocsWereDone()
{
if (head_) {
UtestShell* currentTest = UtestShell::getCurrent();
SimpleString failText;
if (head_->file_)
failText = StringFromFormat("Expected failing alloc at %s:%d was never done", head_->file_, (int) head_->line_)... | subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rax)
je 0x74ccc
callq 0x815a0
movq %rax, 0xe8(%rsp)
leaq 0xd8(%rsp), %rdi
leaq 0x1abc7(%rip), %rsi # 0x8f68a
callq 0x71300
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x74b6c
movq 0x28(%rsp), ... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestMemoryAllocator.cpp |
MemoryAccountant::createNewAccountantAllocationNode(unsigned long, MemoryAccountantAllocationNode*) const | MemoryAccountantAllocationNode* MemoryAccountant::createNewAccountantAllocationNode(size_t size, MemoryAccountantAllocationNode* next) const
{
MemoryAccountantAllocationNode* node = (MemoryAccountantAllocationNode*) (void*) allocator_->alloc_memory(sizeof(MemoryAccountantAllocationNode), __FILE__, __LINE__);
no... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movl $0x30, %esi
leaq 0x19fbe(%rip), %rdx # 0x8ed49
movl $0x199, %ecx # imm = 0x199
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), ... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestMemoryAllocator.cpp |
MemoryAccountant::report() const | SimpleString MemoryAccountant::report() const
{
if (head_ == NULLPTR)
return reportNoAllocations();
SimpleString accountantReport = reportTitle() + reportHeader();
for (MemoryAccountantAllocationNode* node = head_; node; node = node->next_)
accountantReport += StringFromFormat(MEMORY_ACCOUNT... | subq $0xa8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, (%rax)
jne 0x7575b
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x75590
jmp 0x75936
movq 0x18(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x755c0... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestMemoryAllocator.cpp |
GlobalMemoryAccountant::stop() | void GlobalMemoryAccountant::stop()
{
if (mallocAllocator_ == NULLPTR)
FAIL("GlobalMemoryAccount: Stop called without starting");
if (getCurrentMallocAllocator() != mallocAllocator_)
FAIL("GlobalMemoryAccountant: Malloc memory allocator has been changed while accounting for memory");
if (get... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x18(%rax)
jne 0x7620b
jmp 0x76195
callq 0x815a0
movq %rax, 0x38(%rsp)
movq $0x0, 0x78(%rsp)
leaq 0x78(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x137d0
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %r8
movq (%rdi), %rax
movq 0xd0(%rax... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestMemoryAllocator.cpp |
LocationToFailAllocNode::shouldFail(int, char const*, unsigned long) | bool shouldFail(int allocationNumber, const char* file, size_t line)
{
if (file_ && SimpleString::StrCmp(file, file_) == 0 && line == line_) {
actualAllocNumber_++;
return actualAllocNumber_ == allocNumberToFail_;
}
if (allocationNumber == allocNumberToFail_)
return true;
... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x7652e
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rax), %rsi
callq 0x70c90
cmpl $0x0, %eax
jne 0x7652e
movq 0x8(%rsp), %rcx
movq 0x10(%rs... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestMemoryAllocator.cpp |
JUnitTestOutput::resetTestGroupResult() | void JUnitTestOutput::resetTestGroupResult()
{
impl_->results_.testCount_ = 0;
impl_->results_.failureCount_ = 0;
impl_->results_.group_ = "";
JUnitTestCaseResultNode* cur = impl_->results_.head_;
while (cur) {
JUnitTestCaseResultNode* tmp = cur->next_;
delete cur->failure_;
... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rax), %rcx
movq $0x0, (%rcx)
movq 0x20(%rax), %rax
movq $0x0, 0x8(%rax)
leaq 0x18ba9(%rip), %rsi # 0x8f68a
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x71300
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rsi
movq 0x20(%ra... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/JUnitTestOutput.cpp |
JUnitTestOutput::printCurrentTestStarted(UtestShell const&) | void JUnitTestOutput::printCurrentTestStarted(const UtestShell& test)
{
impl_->results_.testCount_++;
impl_->results_.group_ = test.getGroup();
impl_->results_.startTime_ = (size_t) GetPlatformSpecificTimeInMillis();
if (impl_->results_.tail_ == NULLPTR) {
impl_->results_.head_ = impl_->results... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rax), %rax
movq (%rax), %rcx
incq %rcx
movq %rcx, (%rax)
movq 0x78(%rsp), %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x81740
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rsi
movq 0x20(%rax), %rdi
a... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/JUnitTestOutput.cpp |
JUnitTestOutput::encodeFileName(SimpleString const&) | SimpleString JUnitTestOutput::encodeFileName(const SimpleString& fileName)
{
// special character list based on: https://en.wikipedia.org/wiki/Filename
static const char* const forbiddenCharacters = "/\\?%*:|\"<>";
SimpleString result = fileName;
for (const char* sym = forbiddenCharacters; *sym; ++sym)... | subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movb $0x0, 0x2f(%rsp)
movq 0x30(%rsp), %rsi
callq 0x71410
leaq 0x181ec(%rip), %rax # 0x8f311
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpb $0x0, (%rax)
je 0x77177
movq (%rsp),... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/JUnitTestOutput.cpp |
JUnitTestOutput::writeTestSuiteSummary() | void JUnitTestOutput::writeTestSuiteSummary()
{
SimpleString
buf =
StringFromFormat(
"<testsuite errors=\"0\" failures=\"%d\" hostname=\"localhost\" name=\"%s\" tests=\"%d\" time=\"%d.%03d\" timestamp=\"%s\">\n",
(int)impl_->res... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rax), %rdi
movl 0x8(%rdi), %eax
movl %eax, 0x2c(%rsp)
addq $0x28, %rdi
callq 0x72040
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x30(%rsp)
movq 0x20(%rax), %rax
movl (%rax), %ecx
movl %ecx, 0x38(%rsp)
movq 0x20(%rax), %r... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/JUnitTestOutput.cpp |
JUnitTestOutput::encodeXmlText(SimpleString const&) | SimpleString JUnitTestOutput::encodeXmlText(const SimpleString& textbody)
{
SimpleString buf = textbody.asCharString();
buf.replace("&", "&");
buf.replace("\"", """);
buf.replace("<", "<");
buf.replace(">", ">");
buf.replace("\n", "{newline}");
return buf;
} | subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movb $0x0, 0x2f(%rsp)
movq 0x30(%rsp), %rdi
callq 0x72040
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x71300
movq 0x10(%rsp), %rdi
leaq 0x169b9(%rip), %rsi # 0x8de81
leaq 0x... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/JUnitTestOutput.cpp |
JUnitTestOutput::writeTestCases() | void JUnitTestOutput::writeTestCases()
{
JUnitTestCaseResultNode* cur = impl_->results_.head_;
while (cur) {
SimpleString buf = StringFromFormat(
"<testcase classname=\"%s%s%s\" name=\"%s\" assertions=\"%d\" time=\"%d.%03d\" file=\"%s\" line=\"%d\">\n",
impl_->package_.a... | pushq %rbx
subq $0xe0, %rsp
movq %rdi, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x20(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, 0xd0(%rsp)
cmpq $0x0, 0xd0(%rsp)
je 0x778d4
movq 0x78(%rsp), %rax
movq 0x20(%rax), %rdi
addq $0x50, %rdi
callq 0x72040
movq %rax, %rcx
movq 0x78(%rsp), %rax
movq %rcx, 0x4... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/JUnitTestOutput.cpp |
JUnitTestOutput::writeFailure(JUnitTestCaseResultNode*) | void JUnitTestOutput::writeFailure(JUnitTestCaseResultNode* node)
{
SimpleString buf = StringFromFormat(
"<failure message=\"%s:%d: %s\" type=\"AssertionFailedError\">\n",
node->failure_->getFileName().asCharString(),
(int) node->failure_->getFailureLineNumber(),
enco... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xa8(%rsp), %rax
movq 0x18(%rax), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq 0x88(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq *%rax
movq 0x28(%rsp), %rdi
callq 0x72040
movq %rax, 0x30(%rsp)
jmp 0x77947
movq ... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/JUnitTestOutput.cpp |
JUnitTestOutput::writeFileEnding() | void JUnitTestOutput::writeFileEnding()
{
writeToFile("<system-out>");
writeToFile(encodeXmlText(impl_->stdOutput_));
writeToFile("</system-out>\n");
writeToFile("<system-err></system-err>\n");
writeToFile("</testsuite>\n");
} | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x1793b(%rip), %rsi # 0x8f4ae
leaq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x71300
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
movq 0xd0(%rax), %rax
callq *%rax
jmp 0x77b9d
leaq 0x80(%rsp), %rdi
callq 0x72... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/JUnitTestOutput.cpp |
JUnitTestOutput::printFailure(TestFailure const&) | void JUnitTestOutput::printFailure(const TestFailure& failure)
{
if (impl_->results_.tail_->failure_ == NULLPTR) {
impl_->results_.failureCount_++;
impl_->results_.tail_->failure_ = new TestFailure(failure);
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rax), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x77f16
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rcx
incq %rcx
movq %rcx, 0x8(%rax)
leaq 0x173be(%rip), %rsi # 0x8f270
mo... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/JUnitTestOutput.cpp |
TeamCityTestOutput::printEscaped(char const*) | void TeamCityTestOutput::printEscaped(const char* s)
{
while (*s) {
char str[3];
if ((*s == '\'') || (*s == '|') || (*s == '[') || (*s == ']')) {
str[0] = '|';
str[1] = *s;
str[2] = 0;
} else if (*s == '\r') {
str[0] = '|';
str[1] =... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpb $0x0, (%rax)
je 0x78564
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0x784da
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x7c, %eax
je 0x784da
movq 0x18(%rsp), %rax
mov... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TeamCityTestOutput.cpp |
TeamCityTestOutput::printFailure(TestFailure const&) | void TeamCityTestOutput::printFailure(const TestFailure& failure)
{
print("##teamcity[testFailed name='");
printEscaped(failure.getTestNameOnly().asCharString());
print("' message='");
if (failure.isOutsideTestFile() || failure.isInHelperFunction()) {
print("TEST failed (");
print(failur... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq (%rdi), %rax
movq 0x58(%rax), %rax
leaq 0x16da6(%rip), %rsi # 0x8f5b8
callq *%rax
movq 0x98(%rsp), %rsi
movq (%rsi), %rax
movq 0x20(%rax), %rax
leaq 0x88(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq *%rax
movq 0... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TeamCityTestOutput.cpp |
TestFailure::TestFailure(UtestShell*, SimpleString const&) | TestFailure::TestFailure(UtestShell* test, const SimpleString& theMessage) :
testName_(test->getFormattedName()), testNameOnly_(test->getName()), fileName_(test->getFile()), lineNumber_(test->getLineNumber()), testFileName_(test->getFile()), testLineNumber_(test->getLineNumber()), message_(theMessage)
{
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x40(%rsp)
leaq 0x4bb84(%rip), %rax # 0xc47c8
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x38(%rsp)
movq 0x68(%rsp), %rsi
movq (%rsi), %rax
movq 0x28(%rax), %rax
callq *%rax
movq 0x40(%rsp), %rdi
ad... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestFailure.cpp |
TestFailure::createDifferenceAtPosString(SimpleString const&, unsigned long, TestFailure::DifferenceFormat) | SimpleString TestFailure::createDifferenceAtPosString(const SimpleString& actual, size_t position, DifferenceFormat format)
{
SimpleString result;
const size_t extraCharactersWindow = 20;
const size_t halfOfExtraCharactersWindow = extraCharactersWindow / 2;
const size_t actualOffset = (format == DIFFERE... | subq $0x148, %rsp # imm = 0x148
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
movq %rcx, 0x128(%rsp)
movl %r8d, 0x124(%rsp)
movb $0x0, 0x123(%rsp)
leaq 0x163bf(%rip), %rsi # 0x8f68a
callq 0x71300
movq $0x14, 0x118(%rsp)
mo... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestFailure.cpp |
removeAllPrintableCharactersFrom(SimpleString const&) | static SimpleString removeAllPrintableCharactersFrom(const SimpleString& str)
{
size_t bufferSize = str.size()+1;
char* buffer = (char*) PlatformSpecificMalloc(bufferSize);
str.copyToBuffer(buffer, bufferSize);
for (size_t i = 0; i < bufferSize-1; i++)
if (buffer[i] != '\t' && buffer[i] != '\n'... | subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x71280
addq $0x1, %rax
movq %rax, 0x40(%rsp)
leaq 0x4d2db(%rip), %rax # 0xc6ab0
movq (%rax), %rax
movq 0x40(%rsp), %rdi
callq *%rax
movq %rax, 0x38(%rsp)
movq 0x48(%rs... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestFailure.cpp |
addMarkerToString(SimpleString const&, int) | static SimpleString addMarkerToString(const SimpleString& str, int markerPos)
{
size_t bufferSize = str.size()+1;
char* buffer = (char*) PlatformSpecificMalloc(bufferSize);
str.copyToBuffer(buffer, bufferSize);
buffer[markerPos] = '^';
SimpleString result(buffer);
PlatformSpecificFree(buffer);... | subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq 0x48(%rsp), %rdi
callq 0x71280
incq %rax
movq %rax, 0x38(%rsp)
leaq 0x4d1a8(%rip), %rax # 0xc6ab0
movq (%rax), %rax
movq 0x38(%rsp), %rdi
callq *%rax
movq %rax, 0x30(%rs... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestFailure.cpp |
TestFailure::createUserText(SimpleString const&) | SimpleString TestFailure::createUserText(const SimpleString& text)
{
SimpleString userMessage = "";
if (!text.isEmpty())
{
//This is a kludge to turn off "Message: " for this case.
//I don't think "Message: " adds anything, as you get to see the
//message. I propose we remove "Messag... | subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movb $0x0, 0x4f(%rsp)
leaq 0x15cae(%rip), %rsi # 0x8f68a
callq 0x71300
movq 0x50(%rsp), %rdi
callq 0x72050
movb %al, 0x27(%rsp)
jmp 0x799f1
movb 0x27(%rsp), %al
testb $0x1, ... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestFailure.cpp |
EqualsFailure::EqualsFailure(UtestShell*, char const*, unsigned long, char const*, char const*, SimpleString const&) | EqualsFailure::EqualsFailure(UtestShell* test, const char* fileName, size_t lineNumber, const char* expected, const char* actual, const SimpleString& text) :
TestFailure(test, fileName, lineNumber)
{
message_ = createUserText(text);
message_ += createButWasString(StringFromOrNull(expected), StringFromOrNul... | subq $0x88, %rsp
movq 0x90(%rsp), %rax
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
callq 0x78d90
movq (%rsp), %rsi
leaq 0x4ace5(... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestFailure.cpp |
EqualsFailure::EqualsFailure(UtestShell*, char const*, unsigned long, SimpleString const&, SimpleString const&, SimpleString const&) | EqualsFailure::EqualsFailure(UtestShell* test, const char* fileName, size_t lineNumber, const SimpleString& expected, const SimpleString& actual, const SimpleString& text)
: TestFailure(test, fileName, lineNumber)
{
message_ = createUserText(text);
message_ += createButWasString(expected, actual);
} | subq $0x68, %rsp
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
callq 0x78d90
movq (%rsp), %rsi
leaq 0x4ab61(... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestFailure.cpp |
DoublesEqualFailure::DoublesEqualFailure(UtestShell*, char const*, unsigned long, double, double, double, SimpleString const&) | DoublesEqualFailure::DoublesEqualFailure(UtestShell* test, const char* fileName, size_t lineNumber, double expected, double actual, double threshold, const SimpleString& text)
: TestFailure(test, fileName, lineNumber)
{
message_ = createUserText(text);
message_ += createButWasString(StringFrom(expected, 7), St... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movsd %xmm0, 0x90(%rsp)
movsd %xmm1, 0x88(%rsp)
movsd %xmm2, 0x80(%rsp)
movq %r8, 0x78(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0xa8(%rsp), %rsi
movq 0xa0(%rsp), %rdx
movq 0x98(%rsp), %rcx
callq 0x78d9... | /approvals[P]ApprovalTests/build_O0/CMake/cpputest/cpputest-src/src/CppUTest/TestFailure.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.