name string | code string | asm string | file string |
|---|---|---|---|
testing::internal::DeathTestImpl::ReadAndInterpretStatusByte() | void DeathTestImpl::ReadAndInterpretStatusByte() {
char flag;
int bytes_read;
// The read() here blocks until data is available (signifying the
// failure of the death test) or until the pipe is closed (signifying
// its success), so it's okay to call this in the parent before
// the child process has exit... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, %rbx
leaq 0x6(%rsp), %r14
pushq $0x1
popq %r15
movl 0x24(%rbx), %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x206f0
cmpl $-0x1, %eax
jne 0x2d70c
callq 0x20060
cmpl $0x4, (%rax)
je 0x2d6ed
jmp 0x2d750
testl %eax, %eax
je 0x2... | /valbok[P]bvh3/lib/gtest/src/gtest-death-test.cc |
testing::internal::ForkingDeathTest::Wait() | int ForkingDeathTest::Wait() {
if (!spawned())
return 0;
ReadAndInterpretStatusByte();
int status_value;
GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
set_status(status_value);
return status_value;
} | pushq %r14
pushq %rbx
subq $0x118, %rsp # imm = 0x118
xorl %eax, %eax
cmpb $0x1, 0x18(%rdi)
jne 0x2e3c9
movq %rdi, %rbx
callq 0x2d6d4
leaq 0x10(%rsp), %r14
movl 0x2c(%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x20350
cmpl $-0x1, %eax
jne 0x2e3c2
callq 0x20060
cmpl $0x4, (%rax)
je 0x2e2d5
leaq 0xd3a2(%... | /valbok[P]bvh3/lib/gtest/src/gtest-death-test.cc |
testing::internal::ExecDeathTest::AssumeRole() | DeathTest::TestRole ExecDeathTest::AssumeRole() {
const UnitTestImpl* const impl = GetUnitTestImpl();
const InternalRunDeathTestFlag* const flag =
impl->internal_run_death_test_flag();
const TestInfo* const info = impl->current_test_info();
const int death_test_index = info->result()->death_test_count();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, %rbx
callq 0x31ad0
movq 0x110(%rax), %r14
movq 0x1d0(%rax), %rax
movl 0xd0(%r14), %ecx
movl %ecx, 0xf4(%rsp)
testq %rax, %rax
je 0x2eaf8
movl 0x28(%rax), %eax
movl %eax, 0x28(%rbx)
pushq $0x1
popq %rax
jmp 0x2f2d6
leaq 0xe... | /valbok[P]bvh3/lib/gtest/src/gtest-death-test.cc |
testing::internal::FilePath::GetCurrentDir() | FilePath FilePath::GetCurrentDir() {
#if GTEST_OS_WINDOWS_MOBILE
// Windows CE doesn't have a current directory, so we just return
// something reasonable.
return FilePath(kCurrentDirectoryString);
#elif GTEST_OS_WINDOWS
char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
return FilePath(_getcwd(cwd, sizeof(cwd)) == NU... | pushq %r14
pushq %rbx
subq $0x1038, %rsp # imm = 0x1038
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movl $0x1001, %edx # imm = 0x1001
movq %r14, %rdi
xorl %esi, %esi
callq 0x20250
movl $0x1001, %esi # imm = 0x1001
movq %r14, %rdi
callq 0x20220
testq %rax, %rax
leaq 0xaf7b(%rip), %rsi # 0x3b... | /valbok[P]bvh3/lib/gtest/src/gtest-filepath.cc |
testing::internal::FilePath::RemoveExtension(char const*) const | FilePath FilePath::RemoveExtension(const char* extension) const {
const std::string dot_extension = std::string(".") + extension;
if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
return FilePath(pathname_.substr(
0, pathname_.length() - dot_extension.length()));
}
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa737(%rip), %rsi # 0x3a858
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x201a0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x31a79
leaq 0x10(%rsp), %rdi
callq 0x209c8
leaq 0x30(%rsp),... | /valbok[P]bvh3/lib/gtest/src/gtest-filepath.cc |
testing::internal::FilePath::MakeFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, int, char const*) | FilePath FilePath::MakeFileName(const FilePath& directory,
const FilePath& base_name,
int number,
const char* extension) {
std::string file;
if (number == 0) {
file = base_name.string() + "." + extension;
} else {
... | pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %r8, %r15
movq %rsi, %r14
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movl %ecx, 0xc(%rsp)
movb $0x0, (%rax)
testl %ecx, %ecx
je 0x302d7
leaq 0xb7f5(%rip), %rax # 0x3ba20
leaq 0x90(%rsp), %rdi
movq %rdx, %rsi
movq %rax, %... | /valbok[P]bvh3/lib/gtest/src/gtest-filepath.cc |
testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**) | void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) {
if (*stream != NULL) {
GTEST_LOG_(FATAL) << "Only one " << stream_name
<< " capturer can exist at a time.";
}
*stream = new CapturedStream(fd);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %edi, %ebp
cmpq $0x0, (%rdx)
je 0x3097d
movq %rsi, %r14
leaq 0xb081(%rip), %rdx # 0x3b9b5
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x27d, %ecx # imm = 0x27D
callq 0x3077a
movq 0x1b69b(%rip), %rdi # 0x4bfe8
leaq 0xb0f6(%rip... | /valbok[P]bvh3/lib/gtest/src/gtest-port.cc |
testing::internal::FlagToEnvVar[abi:cxx11](char const*) | static std::string FlagToEnvVar(const char* flag) {
const std::string full_flag =
(Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
Message env_var;
for (size_t i = 0; i != full_flag.length(); i++) {
env_var << ToUpper(full_flag.c_str()[i]);
}
return env_var.GetString();
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x25560
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0xaace(%rip), %rsi # 0x3b568
callq 0x20400
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x31e3e
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x2... | /valbok[P]bvh3/lib/gtest/src/gtest-port.cc |
void testing::internal::PrintCharsAsStringTo<char>(char const*, unsigned long, std::ostream*) | static void PrintCharsAsStringTo(
const CharType* begin, size_t len, ostream* os) {
const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
*os << kQuoteBegin;
bool is_previous_hex = false;
for (size_t index = 0; index < len; ++index) {
const CharType cur = begin[index];
if (is_previou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x9d4e(%rip), %r12 # 0x3aa19
movq %rdx, %rdi
movq %r12, %rsi
callq 0x20400
xorl %r13d, %r13d
xorl %eax, %eax
cmpq %r13, %r14
je 0x30d25
movzbl (%r15,%r13), %ebp
testb $0x1, %al
je 0x30d... | /valbok[P]bvh3/lib/gtest/src/gtest-printers.cc |
testing::TestPartResult::ExtractSummary[abi:cxx11](char const*) | std::string TestPartResult::ExtractSummary(const char* message) {
const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
return stack_trace == NULL ? message :
std::string(message, stack_trace);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8a49(%rip), %rsi # 0x398a8
movq %r14, %rdi
callq 0x200d0
testq %rax, %rax
je 0x30e83
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3699e
jmp 0x30e93
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r... | /valbok[P]bvh3/lib/gtest/src/gtest-test-part.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<char [11]>(char const (&) [11]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x25560
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x20400
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36b80
leaq 0x8(%rsp), %rdi
callq 0x235da
movq %rbx, %rax
addq $0x10, %rsp
pop... | /valbok[P]bvh3/lib/gtest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [2]>(char const (&) [2]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x25560
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x20400
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36b80
leaq 0x8(%rsp), %rdi
callq 0x235da
movq %rbx, %rax
addq $0x10, %rsp
pop... | /valbok[P]bvh3/lib/gtest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [14]>(char const (&) [14]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x25560
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x20400
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36b80
leaq 0x8(%rsp), %rdi
callq 0x235da
movq %rbx, %rax
addq $0x10, %rsp
pop... | /valbok[P]bvh3/lib/gtest/include/gtest/gtest.h |
int testing::internal::CountIf<std::vector<testing::TestCase*, std::allocator<testing::TestCase*>>, bool (*)(testing::TestCase const*)>(std::vector<testing::TestCase*, std::allocator<testing::TestCase*>> const&, bool (*)(testing::TestCase const*)) | inline int CountIf(const Container& c, Predicate predicate) {
// Implemented as an explicit loop since std::count_if() in libCstd on
// Solaris has a non-standard signature.
int count = 0;
for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
if (predicate(*it))
++count;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
xorl %ebp, %ebp
cmpq 0x8(%r14), %r15
je 0x31e31
movq (%r15), %rdi
callq *%rbx
movzbl %al, %eax
addl %eax, %ebp
addq $0x8, %r15
jmp 0x31e1b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq... | /valbok[P]bvh3/lib/gtest/src/gtest-internal-inl.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [24]>(char const (&) [24]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x25560
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x20400
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36b80
leaq 0x8(%rsp), %rdi
callq 0x235da
movq %rbx, %rax
addq $0x10, %rsp
pop... | /valbok[P]bvh3/lib/gtest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [5]>(char const (&) [5]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x25560
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x20400
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36b80
leaq 0x8(%rsp), %rdi
callq 0x235da
movq %rbx, %rax
addq $0x10, %rsp
pop... | /valbok[P]bvh3/lib/gtest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [9]>(char const (&) [9]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x25560
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x20400
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36b80
leaq 0x8(%rsp), %rdi
callq 0x235da
movq %rbx, %rax
addq $0x10, %rsp
pop... | /valbok[P]bvh3/lib/gtest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [13]>(char const (&) [13]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x25560
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x20400
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36b80
leaq 0x8(%rsp), %rdi
callq 0x235da
movq %rbx, %rax
addq $0x10, %rsp
pop... | /valbok[P]bvh3/lib/gtest/include/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [6]>(char const (&) [6]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x20400
movq %rbx, %rax
popq %rbx
retq
nop
| /valbok[P]bvh3/lib/gtest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [30]>(char const (&) [30]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x20400
movq %rbx, %rax
popq %rbx
retq
nop
| /valbok[P]bvh3/lib/gtest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [39]>(char const (&) [39]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x20400
movq %rbx, %rax
popq %rbx
retq
nop
| /valbok[P]bvh3/lib/gtest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [62]>(char const (&) [62]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x20400
movq %rbx, %rax
popq %rbx
retq
nop
| /valbok[P]bvh3/lib/gtest/include/gtest/gtest-message.h |
testing::internal::ParameterizedTestCaseRegistry::RegisterTests() | void RegisterTests() {
for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
it != test_case_infos_.end(); ++it) {
(*it)->RegisterTests();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rbx), %r14
je 0x3313d
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x8, %r14
jmp 0x33128
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /valbok[P]bvh3/lib/gtest/include/gtest/internal/gtest-param-util.h |
testing::Test* testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::TestFactoryBase, testing::Test*>(testing::internal::TestFactoryBase*, testing::Test* (testing::internal::TestFactoryBase::*)(), char const*) | Result HandleExceptionsInMethodIfSupported(
T* object, Result (T::*method)(), const char* location) {
// NOTE: The user code can affect the way in which Google Test handles
// exceptions by setting GTEST_FLAG(catch_exceptions), but only before
// RUN_ALL_TESTS() starts. It is technically possible to check the... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x31ad0
addq %r15, %r14
cmpb $0x1, 0x200(%rax)
jne 0x3318d
testb $0x1, %r12b
je 0x3317b
movq (%r14), %rax
movq -0x1(%rax,%r12), %r12
movq %r14, %rdi
callq *%r12
addq $0x28, %rsp
popq %rbx
p... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::Message& testing::Message::operator<<<char [4]>(char const (&) [4]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x20400
movq %rbx, %rax
popq %rbx
retq
| /valbok[P]bvh3/lib/gtest/include/gtest/gtest-message.h |
testing::internal::GetRandomSeedFromFlag(int) | inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {
const unsigned int raw_seed = (random_seed_flag == 0) ?
static_cast<unsigned int>(GetTimeInMillis()) :
static_cast<unsigned int>(random_seed_flag);
// Normalizes the actual seed to range [1, kMaxRandomSeed] such that
// it's easy to type.
c... | movl %edi, %eax
testl %edi, %edi
jne 0x33d03
pushq %rax
callq 0x25503
addq $0x8, %rsp
decl %eax
movl $0x1869f, %ecx # imm = 0x1869F
xorl %edx, %edx
divl %ecx
leal 0x1(%rdx), %eax
retq
| /valbok[P]bvh3/lib/gtest/src/gtest-internal-inl.h |
void testing::internal::InitGoogleTestImpl<char>(int*, char**) | void InitGoogleTestImpl(int* argc, CharType** argv) {
g_init_gtest_count++;
// We don't want to run the initialization code twice.
if (g_init_gtest_count != 1) return;
if (*argc <= 0) return;
internal::g_executable_path = internal::StreamableToString(argv[0]);
#if GTEST_HAS_DEATH_TEST
g_argvs.clear();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl 0x18024(%rip), %eax # 0x4c624
leal 0x1(%rax), %ecx
movl %ecx, 0x1801b(%rip) # 0x4c624
testl %eax, %eax
jne 0x3469f
movq %rdi, %r14
cmpl $0x0, (%rdi)
jle 0x3469f
movq %rsi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x38... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::GetPrefixUntilComma[abi:cxx11](char const*) | inline std::string GetPrefixUntilComma(const char* str) {
const char* comma = strchr(str, ',');
return comma == NULL ? str : std::string(str, comma);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0x20190
testq %rax, %rax
je 0x3500b
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3699e
jmp 0x3501b
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x... | /valbok[P]bvh3/lib/gtest/include/gtest/internal/gtest-internal.h |
testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&) | void OnTestEnd(const TestInfo& test_info) {
SendLn("event=TestEnd&passed=" +
FormatBool((test_info.result())->Passed()) +
"&elapsed_time=" +
StreamableToString((test_info.result())->elapsed_time()) + "ms");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x68(%rsi), %rdi
callq 0x33478
movzbl %al, %edx
leaq 0xb0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3642e
leaq 0x62b0(%rip), %rsi # 0x3c00c
leaq 0x30(%rsp), %rdi
movq %r15, %rdx
callq 0x327c6
leaq 0x62b2(%rip), %rdx ... | /valbok[P]bvh3/lib/gtest/src/gtest-internal-inl.h |
testing::internal::UniversalTersePrinter<char const*>::Print(char const*, std::ostream*) | static void Print(const char* str, ::std::ostream* os) {
if (str == NULL) {
*os << "NULL";
} else {
UniversalPrint(string(str), os);
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x36aa9
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x201a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e2a
leaq 0x8(%rsp), %rdi
callq 0x209c8
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x5073(%rip), %rsi ... | /valbok[P]bvh3/lib/gtest/include/gtest/gtest-printers.h |
testing::Message& testing::Message::operator<<<long long>(long long const&) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
movq (%rsi), %rsi
callq 0x20180
movq %rbx, %rax
popq %rbx
retq
| /valbok[P]bvh3/lib/gtest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<double>(double const&) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
movsd (%rsi), %xmm0
callq 0x20800
movq %rbx, %rax
popq %rbx
retq
nop
| /valbok[P]bvh3/lib/gtest/include/gtest/gtest-message.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [16]>(char const (&) [16]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x25560
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x20400
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36b80
leaq 0x8(%rsp), %rdi
callq 0x235da
movq %rbx, %rax
addq $0x10, %rsp
pop... | /valbok[P]bvh3/lib/gtest/include/gtest/gtest.h |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::CreateKey() | static pthread_key_t CreateKey() {
pthread_key_t key;
// When a thread exits, DeleteThreadLocalValue() will be called on
// the object managed for that thread.
GTEST_CHECK_POSIX_SUCCESS_(
pthread_key_create(&key, &DeleteThreadLocalValue));
return key;
} | pushq %rbx
subq $0x10, %rsp
leaq -0x18(%rip), %rsi # 0x380ca
leaq 0xc(%rsp), %rdi
callq 0x207c0
testl %eax, %eax
je 0x38141
movl %eax, %ebx
leaq 0x3b00(%rip), %rdx # 0x3bbf9
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x5e8, %ecx # imm = 0x5E8
callq 0x3077a
movq 0x13ed6(%rip), %rdi # 0x4bf... | /valbok[P]bvh3/lib/gtest/include/gtest/internal/gtest-port.h |
void NBvh3::getDistances<8u>(NBvh3::SVertex const&, float*) | inline void getDistances<8>(const SVertex& vertex, float dists[])
{
dists[0] = vertex.x;
dists[1] = vertex.y;
dists[2] = vertex.z;
dists[3] = vertex.x + vertex.y;
dists[4] = vertex.x + vertex.z;
dists[5] = vertex.y + vertex.z;
dists[6] = vertex.x - vertex.y;
dists[7] = vertex.x - vertex.... | movss (%rdi), %xmm0
movss %xmm0, (%rsi)
movss 0x4(%rdi), %xmm0
movss %xmm0, 0x4(%rsi)
movss 0x8(%rdi), %xmm0
movss %xmm0, 0x8(%rsi)
movss (%rdi), %xmm0
addss 0x4(%rdi), %xmm0
movss %xmm0, 0xc(%rsi)
movss (%rdi), %xmm0
addss 0x8(%rdi), %xmm0
movss %xmm0, 0x10(%rsi)
movss 0x4(%rdi), %xmm0
addss 0x8(%rdi), %xmm0
movss %xm... | /valbok[P]bvh3/bvh3/bv/KDop.cpp |
NBvh3::KDop<16u>::operator+=(NBvh3::SVertex const&) | KDop<K>& KDop<K>::operator += (const SVertex& vertex)
{
float dists[K / 2];
getDistances<K / 2>(vertex, dists);
for(unsigned i = 0; i < K / 2; ++i)
{
setMinMax(dists[i], mMin[i], mMax[i]);
}
return *this;
} | movq %rdi, %rax
movss 0x8(%rsi), %xmm0
movss %xmm0, -0x20(%rsp)
movsd (%rsi), %xmm1
movaps %xmm1, %xmm2
shufps $0x11, %xmm1, %xmm2 # xmm2 = xmm2[1,0],xmm1[1,0]
movss %xmm1, -0x28(%rsp)
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3 # xmm3 = xmm3[1,1],xmm1[1,1]
movss %xmm3, -0x24(%rsp)
movaps %xmm1, %xmm3
movlhp... | /valbok[P]bvh3/bvh3/bv/KDop.cpp |
NBvh3::KDop<24u>::operator+=(NBvh3::KDop<24u> const&) | KDop<K>& KDop<K>::operator += (const KDop<K>& other)
{
for (unsigned i = 0; i < K / 2; ++i)
{
if (other.mMin[i] < mMin[i])
{
mMin[i] = other.mMin[i];
}
if (other.mMax[i] > mMax[i])
{
mMax[i] = other.mMax[i];
}
}
return *this;
} | movq %rdi, %rax
xorl %ecx, %ecx
cmpq $0xc, %rcx
je 0x38f5b
movss (%rsi,%rcx,4), %xmm0
movss (%rax,%rcx,4), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x38f43
movss %xmm0, (%rax,%rcx,4)
movss 0x30(%rsi,%rcx,4), %xmm0
ucomiss 0x30(%rax,%rcx,4), %xmm0
jbe 0x38f56
movss %xmm0, 0x30(%rax,%rcx,4)
incq %rcx
jmp 0x38f29
retq
| /valbok[P]bvh3/bvh3/bv/KDop.cpp |
cb_end_packet | static enum rfc5444_result
cb_end_packet(struct rfc5444_reader_tlvblock_context *c,
bool dropped __attribute__ ((unused))) {
int oi = c->consumer->order - 1;
#ifdef PRINT_CB
printf("%s: packet end (order %d): %d\n", __func__, c->consumer->order, callback_index);
#endif
idxcb_end_packet[oi] = callback_index++... | pushq %rbx
movq 0x8(%rdi), %rax
movslq 0x38(%rax), %rbx
movl 0x5c1c(%rip), %ecx # 0x154e8
leaq 0x1792(%rip), %rdi # 0x11065
leaq 0x17aa(%rip), %rsi # 0x11084
movl %ebx, %edx
xorl %eax, %eax
callq 0x1040
movl 0x5bff(%rip), %eax # 0x154e8
leal 0x1(%rax), %ecx
movl %ecx, 0x5bf6(%rip) # 0x154e8
lea... | /OLSR[P]OONF/src/tests/rfc5444/test_rfc5444_reader_dropcontext.c |
void read_ascii_from_string_invoker::run<float>(boost::type<float>*) | BOOST_AUTO_TEST_CASE_TEMPLATE(read_ascii_from_string, T, test_types)
{
using solid = stl::basic_solid<T>;
std::string str = "solid Hi you\n \
facet normal 0.5 0.6 0.7\n\
outer loop\n\
vertex 0.5 0.6 0.7\n\
vertex 0.5 0.6 0.7\n\
vertex 0.5 0.6 0.7\n\
endloop\n\
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
leaq 0x30(%rsp), %rbx
movl $0x198, %edx # imm = 0x198
movq %rbx, %rdi
xorl %esi, %esi
callq 0x19270
movq %rbx, %rdi
callq 0x19670
leaq 0x1b8(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
mo... | /TinyTinni[P]FileSTL/test/stl_parser_test.cpp |
tyti::stl::stl_parser_binary<float, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::stl_parser_binary() | stl_parser_binary() : stl_parser_binary::base_type(start)
{
namespace spirit = boost::spirit;
namespace qi = boost::spirit::qi;
namespace ql = qi::labels;
namespace ascii = boost::spirit::ascii;
namespace px = boost::phoenix;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %r12
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x21a06(%rip), %rsi # 0x7b31e
leaq 0x21a0e(%rip), %rdx # 0x7b32d
leaq 0x8(%rsp), %rdi
callq 0x4faf8
leaq 0x28(%r12), %r14
movq %r14, (%r1... | /TinyTinni[P]FileSTL/test/../stlio.hpp |
tyti::stl::stl_parser_ascii<float, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::~stl_parser_ascii() | stl_parser_ascii() : stl_parser_ascii::base_type(start)
{
namespace qi = boost::spirit::qi;
namespace ql = qi::labels;
namespace ascii = boost::spirit::ascii;
namespace fusion = boost::fusion;
namespace px = boost::phoenix;
... | pushq %rbx
movq %rdi, %rbx
addq $0x128, %rdi # imm = 0x128
callq 0x5a3b2
movq 0x108(%rbx), %rdi
leaq 0x118(%rbx), %rax
cmpq %rax, %rdi
je 0x59d74
movq (%rax), %rsi
incq %rsi
callq 0x194d0
leaq 0xe0(%rbx), %rdi
callq 0x5a8b4
movq 0xc0(%rbx), %rdi
leaq 0xd0(%rbx), %rax
cmpq %rax, %rdi
je 0x59d9e
movq (%rax), %... | /TinyTinni[P]FileSTL/test/../stlio.hpp |
std::pair<tyti::stl::basic_solid<float>, bool> tyti::stl::read<float>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline std::pair<basic_solid<T>, bool> read(const std::string& fileName)
{
basic_solid<T> out;
bool r = read(out, fileName);
return std::make_pair<basic_solid<T>, bool>(std::move(out), std::move(r));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movups %xmm0, 0x20(%r15)
movups %xmm0, 0x30(%r15)
movups %xmm0, 0x40(%r15)
movq %rax, 0x50(%r15)
leaq 0x8(%rs... | /TinyTinni[P]FileSTL/test/../stlio.hpp |
bool tyti::stl::read<float>(tyti::stl::basic_solid<float>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline bool read(basic_solid<T>& out, const std::string& fileName)
{
std::ifstream f(fileName, std::ios::binary);
std::string str;
f.seekg(0, std::ios::end);
str.resize((unsigned)f.tellg());
f.seekg(0, std::ios::beg);
f.read(&str[0], str.si... | pushq %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp # imm = 0x230
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x4, %edx
callq 0x197a0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x19680
leaq 0x28(%rs... | /TinyTinni[P]FileSTL/test/../stlio.hpp |
tyti::stl::stl_parser<float, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::stl_parser() | stl_parser() : stl_parser::base_type(start)
{
start %= stl_ascii_ | boost::spirit::qi::lexeme[stl_binary_];
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x17591(%rip), %rsi # 0x7b31e
leaq 0x17599(%rip), %rdx # 0x7b32d
movq %rsp, %rdi
callq 0x4faf8
leaq 0x270(%r15), %r12
movq %r12, (%r15)
leaq 0x8(%r15), %rbx
leaq 0... | /TinyTinni[P]FileSTL/test/../stlio.hpp |
tyti::stl::stl_parser_binary<float, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::~stl_parser_binary() | stl_parser_binary() : stl_parser_binary::base_type(start)
{
namespace spirit = boost::spirit;
namespace qi = boost::spirit::qi;
namespace ql = qi::labels;
namespace ascii = boost::spirit::ascii;
namespace px = boost::phoenix;
... | pushq %rbx
movq %rdi, %rbx
addq $0xe0, %rdi
callq 0x67d04
movq 0xc0(%rbx), %rdi
leaq 0xd0(%rbx), %rax
cmpq %rax, %rdi
je 0x64868
movq (%rax), %rsi
incq %rsi
callq 0x194d0
leaq 0x98(%rbx), %rdi
callq 0x67200
movq 0x78(%rbx), %rdi
leaq 0x88(%rbx), %rax
cmpq %rax, %rdi
je 0x6488f
movq (%rax), %rsi
incq %rsi
callq 0x194d0
... | /TinyTinni[P]FileSTL/test/../stlio.hpp |
tyti::stl::stl_parser<double, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::~stl_parser() | stl_parser() : stl_parser::base_type(start)
{
start %= stl_ascii_ | boost::spirit::qi::lexeme[stl_binary_];
} | pushq %rbx
movq %rdi, %rbx
addq $0x298, %rdi # imm = 0x298
callq 0x6a7da
movq 0x278(%rbx), %rdi
leaq 0x288(%rbx), %rax
cmpq %rax, %rdi
je 0x696cc
movq (%rax), %rsi
incq %rsi
callq 0x194d0
leaq 0x170(%rbx), %rdi
callq 0x69fc6
leaq 0x28(%rbx), %rdi
callq 0x6a058
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx,... | /TinyTinni[P]FileSTL/test/../stlio.hpp |
void tyti::stl::write_binary<float, std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, tyti::stl::basic_solid<float> const&) | void write_binary(streamT& out, const basic_solid<T>& s)
{
// fill header buffer
const size_t HEADER_SIZE = 80;
char header_buffer[HEADER_SIZE];
const size_t to_write = std::min(s.header.size(), HEADER_SIZE);
std::copy(s.header.begin(), s.header.end(),... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r12
cmpq $0x50, %r12
movl $0x50, %r15d
movl $0x50, %r13d
cmovbq %r12, %r13
testq %r12, %r12
je 0x7001c
movq (%rbx), %rsi
leaq 0x10(%rsp), %rdi
movq %r12, %rdx
callq 0x197b0
cmpq $0x4f, %r1... | /TinyTinni[P]FileSTL/test/../stlio.hpp |
test | int test(char *URL)
{
CURL *curl;
CURLcode res = CURLE_OK;
struct curl_slist *slist = NULL;
struct WriteThis pooh;
pooh.counter = 0;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
fprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!c... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movl $0x0, 0x4(%rsp)
movl $0x3, %edi
callq 0x1100
testl %eax, %eax
je 0x1259
movq 0x2d95(%rip), %rax # 0x3fd8
movq (%rax), %rdi
leaq 0xdb7(%rip), %rsi # 0x2004
xorl %eax, %eax
callq 0x10d0
jmp 0x13cc
callq 0x1050
testq %rax, %rax
je 0x138... | /macressler[P]curl/tests/libtest/lib510.c |
Catch::operator<<(std::ostream&, Catch::SourceLineInfo const&) | std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
#ifndef __GNUG__
os << info.file << '(' << info.line << ')';
#else
os << info.file << ':' << info.line;
#endif
return os;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testq %r15, %r15
je 0x1abd6
movq %r15, %rdi
callq 0x122c0
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x12710
jmp 0x1abed
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %e... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Config::Config(Catch::ConfigData const&) | Config::Config( ConfigData const& data )
: m_data( data ),
m_stream( openStream() )
{
// We need to trim filter specs to avoid trouble with superfluous
// whitespace (esp. important for bdd macros, as those are manually
// aligned with whitespace).
for (auto& elem : m_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdi, %rbx
leaq 0x8ad49(%rip), %rax # 0xa59b0
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x3e018
movq 0x68(%rbx), %rax
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
movq 0x70(%rbx), %rax
mov... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::TestSpecParser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
m_mode = None;
m_exclusion = false;
m_arg = m_tagAliases->expandAliases( arg );
m_escapeChars.clear();
m_substring.reserve(m_arg.size());
m_patternName.reserve(m_arg.size());
m_realPatternPos = 0;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, (%rdi)
movb $0x0, 0x8(%rdi)
movq 0xe0(%rdi), %rsi
movq (%rsi), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq *0x18(%rax)
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x12780
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
c... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Detail::parseEnums(Catch::StringRef) | std::vector<StringRef> parseEnums( StringRef enums ) {
auto enumValues = splitStringRef( enums, ',' );
std::vector<StringRef> parsed;
parsed.reserve( enumValues.size() );
for( auto const& enumValue : enumValues ) {
parsed.push_back(trim(extractInstanceName... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movl $0x2c, %ecx
callq 0x1bba5
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x4, %rsi
movq %rbx, %rdi
callq 0x3e3aa
movq (%rsp)... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Detail::makeEnumInfo(Catch::StringRef, Catch::StringRef, std::vector<int, std::allocator<int>> const&) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
enumInfo->m_name = enumName;
enumInfo->m_values.reserve( values.size() );
const auto valueNames = C... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movq %r8, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %rbp
movl $0x28, %edi
callq 0x12620
movq %rax, %r14
leaq 0x10(%rax), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%r... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::ExceptionTranslatorRegistry::registerTranslator(Catch::IExceptionTranslator const*) | void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
} | pushq %rbx
subq $0x10, %rsp
addq $0x8, %rdi
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x50810
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c015
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c02e
movq (%rdi), %rax
callq *0... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::FatalConditionHandler::engage_platform() | void FatalConditionHandler::engage_platform() {
stack_t sigStack;
sigStack.ss_sp = altStackMem;
sigStack.ss_size = altStackSize;
sigStack.ss_flags = 0;
sigaltstack(&sigStack, &oldSigStack);
struct sigaction sa = { };
sa.sa_handler = handleSignal;
sa.sa_fl... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq 0x8e81f(%rip), %rax # 0xaaad8
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq 0x8e818(%rip), %rax # 0xaaae0
movq %rax, 0x10(%rdi)
movl $0x0, 0x8(%rdi)
leaq 0x8e80e(%rip), %rsi # 0xaaae8
callq 0x12b80
leaq 0x28(%rsp), %rbx
xorl %r15d, %r15d
movl $... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::ReporterConfig::fullConfig() const | IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; } | movq %rdi, %rax
movq 0x8(%rsi), %rcx
movq %rcx, (%rdi)
movq 0x10(%rsi), %rcx
movq %rcx, 0x8(%rdi)
testq %rcx, %rcx
je 0x1c52d
movq 0x8da60(%rip), %rdx # 0xa9f80
cmpb $0x0, (%rdx)
je 0x1c529
incl 0x8(%rcx)
retq
lock
incl 0x8(%rcx)
retq
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::SectionStats::SectionStats(Catch::SectionInfo const&, Catch::Counts const&, double, bool) | SectionStats::SectionStats( SectionInfo const& _sectionInfo,
Counts const& _assertions,
double _durationInSeconds,
bool _missingAssertions )
: sectionInfo( _sectionInfo ),
assertions( _assertions ),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movsd %xmm0, (%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x892d4(%rip), %rax # 0xa5bb0
movq %rax, (%rdi)
leaq 0x8(%rdi), %r13
leaq 0x18(%rdi), %rbp
movq %rbp, 0x8(%rdi)
movq (%rsi), %rsi
movq 0x8(%r12), %rdx... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::TestGroupStats::~TestGroupStats() | TestGroupStats::~TestGroupStats() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x88f57(%rip), %rax # 0xa5bf0
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x1ccb4
movq (%rax), %rsi
incq %rsi
callq 0x12650
movl $0x78, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x12650
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::listTests(Catch::Config const&) | std::size_t listTests( Config const& config ) {
TestSpec const& testSpec = config.testSpec();
if( config.hasTestFilters() )
Catch::cout() << "Matching test cases:\n";
else {
Catch::cout() << "All available test cases:\n";
}
auto matchedTestCases = filterT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, 0x30(%rsp)
movq %rbx, %rdi
callq *0x70(%rax)
movq 0x8d16c(%rip), %rdi # 0xa9f88
testb %al, %al
je 0x1ce2e
leaq 0x5a2ef(%rip), %rsi #... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::TestCaseInfo::tagsAsString[abi:cxx11]() const | std::string TestCaseInfo::tagsAsString() const {
std::string ret;
// '[' and ']' per tag
std::size_t full_size = 2 * tags.size();
for (const auto& tag : tags) {
full_size += tag.size();
}
ret.reserve(full_size);
for (const auto& tag : tags) {
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x60(%rsi), %rax
movq 0x68(%rsi), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x4, %rsi
cmpq %rax, %rcx
je 0x1d4b5
addq 0x8(%rax), %rsi
addq $0x20... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::TagInfo::all[abi:cxx11]() const | std::string TagInfo::all() const {
size_t size = 0;
for (auto const& spelling : spellings) {
// Add 2 for the brackes
size += spelling.size() + 2;
}
std::string out; out.reserve(size);
for (auto const& spelling : spellings) {
out += '[';
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rax
leaq 0x8(%rsi), %r12
xorl %r15d, %r15d
cmpq %r12, %rax
je 0x1d738
movq 0x28(%rax), %rcx
addq %rcx, %r15
addq $0x2, %r15
movq %rax, %rdi
callq 0x12730
jmp 0x1d71e
leaq 0x10(%rbx), %r13
movq %r13, (%rbx)
movq $0x0... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::toLower(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string toLower( std::string const& s ) {
std::string lc = s;
toLowerInPlace( lc );
return lc;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4e2ce
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x1de8f
movq (%rbx), %r15
xorl %r12d, %r12d
movzbl (%r15,%r12), %edi
callq 0x12910
... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Matchers::Exception::ExceptionMessageMatcher::describe[abi:cxx11]() const | std::string ExceptionMessageMatcher::describe() const {
return "exception message matches \"" + m_message + "\"";
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x30(%rsi), %rdx
leaq 0x58dd2(%rip), %rsi # 0x771bf
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3ec0b
leaq 0x5944b(%rip), %rsi # 0x7784c
movq %r14, %rdi
callq 0x12bd0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Matchers::Floating::WithinUlpsMatcher::describe[abi:cxx11]() const | std::string WithinUlpsMatcher::describe() const {
std::stringstream ret;
ret << "is within " << m_ulps << " ULPs of ";
if (m_type == FloatingPointKind::Float) {
write(ret, static_cast<float>(m_target));
ret << 'f';
} else {
write(ret, m_target);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x12470
leaq 0x20(%rsp), %r14
leaq 0x586a0(%rip), %rsi # 0x7720c
movl $0xa, %edx
movq %r14, %rdi
callq 0x12710
movq 0x38(%r15), %rsi
movq %r14, %rdi
callq 0x12430
leaq 0... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Matchers::Generic::Detail::finalizeDescription(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
if (desc.empty()) {
return "matches undescribed predicate";
} else {
return "matches predicate: \"" + desc + '"';
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x1f235
movq %rsi, %rdx
leaq 0x58167(%rip), %rsi # 0x77354
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3ec0b
movq 0x8(%r14), %rsi
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
movl $0x22, %r8d
callq 0x12b70
leaq 0x10(%rbx), %rdx
movq ... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Matchers::StdString::StringMatcherBase::StringMatcherBase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Matchers::StdString::CasedString const&) | StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
: m_comparator( comparator ),
m_operation( operation ) {
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x869c2(%rip), %rax # 0xa5d30
movq %rax, (%rdi)
leaq 0x869e0(%rip), %rax # 0xa5d58
movq %rax, 0x28(%rdi)
movl (%rdx), %eax
movl %eax,... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Matchers::StdString::EqualsMatcher::EqualsMatcher(Catch::Matchers::StdString::CasedString const&) | EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x57d79(%rip), %rsi # 0x7737d
leaq 0x57d78(%rip), %rdx # 0x77383
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x42cf6
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Matchers::StdString::ContainsMatcher::ContainsMatcher(Catch::Matchers::StdString::CasedString const&) | ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x57c64(%rip), %rsi # 0x77384
leaq 0x57c65(%rip), %rdx # 0x7738c
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x42cf6
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::ScopedMessage::ScopedMessage(Catch::MessageBuilder const&) | ScopedMessage::ScopedMessage( MessageBuilder const& builder )
: m_info( builder.m_info ), m_moved()
{
m_info.message = builder.m_stream.str();
getResultCapture().pushScopedMessage( m_info );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
movups 0x18(%rsi), %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r12
movq %r12, 0x10(%rdi)
movq 0x28(%rsi), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4e2ce
movq 0x58(%r15), %rax
mov... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::uncaught_exceptions() | bool uncaught_exceptions() {
#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
return false;
#elif defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
return std::uncaught_exceptions() > 0;
#else
return std::uncaught_exception();
#endif
} | pushq %rax
callq 0x12760
testl %eax, %eax
setg %al
popq %rcx
retq
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Capturer::~Capturer() | Capturer::~Capturer() {
if ( !uncaught_exceptions() ){
assert( m_captured == m_messages.size() );
for( size_t i = 0; i < m_captured; ++i )
m_resultCapture.popScopedMessage( m_messages[i] );
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x12760
testl %eax, %eax
jg 0x206bb
movq 0x8(%rbx), %rcx
movq 0x20(%rbx), %rax
subq (%rbx), %rcx
sarq $0x3, %rcx
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdx
cmpq %rdx, %rax
jne 0x206c8
testq %rax, %rax
je 0x206bb
xorl %r14d, %r14d... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::RedirectedStdOut::RedirectedStdOut() | RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x25548
movq 0x10(%rbx), %rax
movq 0x897a7(%rip), %rdi # 0xa9f88
movq %rdi, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq (%rdi), %rcx
movq -0x18(%rcx), %rdx
movq 0xe8(%rdi,%rdx), %rdx
movq %rdx, 0x28(%rbx)
addq -0x18(%rcx), %rdi
movq (%rax), %rcx
movq -0x18(%rcx), %rc... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::SimplePcg32::operator()() | SimplePcg32::result_type SimplePcg32::operator()() {
// prepare the output value
const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
const auto output = rotate_right(xorshifted, m_state >> 59u);
// advance state
m_state = m_state * 63641362238... | movq (%rdi), %rax
movq %rax, %rdx
movq %rax, %rcx
movabsq $0x5851f42d4c957f2d, %rsi # imm = 0x5851F42D4C957F2D
imulq %rax, %rsi
shrq $0x2d, %rax
shrq $0x1b, %rdx
xorl %edx, %eax
shrq $0x3b, %rcx
rorl %cl, %eax
movabsq $0x27da198a7f2728ed, %rcx # imm = 0x27DA198A7F2728ED
addq %rsi, %rcx
movq %rcx, (%rdi)
retq
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::ReporterRegistry::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<Catch::IConfig const> const&) const | IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
auto it = m_factories.find( name );
if( it == m_factories.end() )
return nullptr;
return it->second->create( ReporterConfig( config ) );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0x4e64c
addq $0x10, %r14
cmpq %r14, %rax
je 0x20c5a
movq 0x40(%rax), %r14
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, 0x8(%rsp)
movq (%r15), %rax
movq %rax, 0... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::RunContext::~RunContext() | RunContext::~RunContext() {
m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x84f0e(%rip), %rax # 0xa5ff0
movq %rax, (%rdi)
leaq 0x84fc4(%rip), %rax # 0xa60b0
movq %rax, 0x8(%rdi)
movq 0x128(%rdi), %r14
movq 0xe0(%rdi), %rdi
movq 0x100(%rbx), %r13
movq (%rdi), %rax
callq *0x48(%rax)
... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::RunContext::runTest(Catch::TestCase const&) | Totals RunContext::runTest(TestCase const& testCase) {
Totals prevTotals = m_totals;
std::string redirectedCout;
std::string redirectedCerr;
auto const& testInfo = testCase.getTestCaseInfo();
m_reporter->testCaseStarting(testInfo);
m_activeTestCase = &testCase;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0xf8(%rsi), %rax
movq %rax, 0x70(%rsp)
movq 0x100(%rsi), %r13
movq 0x108(%rsi), %rbp
movdqu 0x110(%rsi), %xmm0
movdqa %xmm0, 0x80(%rsp)
movq 0x120(%rsi), %r12... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::RunContext::runCurrentTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
m_reporter->sectionStarting(testCaseSection);
Counts prevAs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x38(%rdi), %rbp
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %r12
movq %r12, %rdi
cal... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::RunContext::acquireGeneratorTracker(Catch::StringRef, Catch::SourceLineInfo const&) | auto RunContext::acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
using namespace Generators;
GeneratorTracker& tracker = GeneratorTracker::acquire(m_trackerContext,
TestCaseTracking::... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x42cf6
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x20... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::RunContext::sectionEnded(Catch::SectionEndInfo const&) | void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
Counts assertions = m_totals.assertions - endInfo.prevAssertions;
bool missingAssertions = testForMissingAssertions(assertions);
if (!m_activeSections.empty()) {
m_activeSections.back()->close();
m_activeSec... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movdqu 0xf8(%rdi), %xmm0
movdqu 0x50(%rsi), %xmm1
psubq %xmm1, %xmm0
movq %rsp, %rsi
movdqa %xmm0, (%rsi)
movq 0x108(%rdi), %rax
subq 0x60(%r14), %rax
movq %rax, 0x10(%rsi)
callq 0x223d8
movl %eax, %ebp
movq 0x1b8(%r... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::RunContext::getCurrentTestName[abi:cxx11]() const | std::string RunContext::getCurrentTestName() const {
return m_activeTestCase
? m_activeTestCase->getTestCaseInfo().name
: std::string();
} | pushq %rbx
movq %rdi, %rbx
movq 0x38(%rsi), %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
testq %rax, %rax
je 0x22634
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4e2ce
jmp 0x22640
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::RunContext::assertionPassed() | void RunContext::assertionPassed() {
m_lastAssertionPassed = true;
++m_totals.assertions.passed;
resetAssertionInfo();
m_messageScopes.clear();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, 0x1e9(%rdi)
incq 0xf8(%rdi)
leaq 0x543ac(%rip), %rax # 0x76f3f
movq %rax, 0x160(%rdi)
movq $0x0, 0x168(%rdi)
leaq 0x5499a(%rip), %rax # 0x77546
movq %rax, 0x180(%rdi)
movq $0x2c, 0x188(%rdi)
movq 0x148(%rdi), %r15
movq 0x150(%rdi), %r12
cmpq %r15... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::RunContext::reportExpr(Catch::AssertionInfo const&, Catch::ResultWas::OfType, Catch::ITransientExpression const*, bool) | void RunContext::reportExpr(
AssertionInfo const &info,
ResultWas::OfType resultType,
ITransientExpression const *expr,
bool negated ) {
m_lastAssertionInfo = info;
AssertionResultData data( resultType, LazyExpression( negated ) );
AssertionResul... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movl 0x30(%rsi), %eax
movl %eax, 0x190(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x180(%rdi)
movups %xmm1, 0x170(%rdi)
movups %xmm0, 0x160(%rdi)
leaq 0x10(%rsp), %r15
movq %r15, ... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::RunContext::handleMessage(Catch::AssertionInfo const&, Catch::ResultWas::OfType, Catch::StringRef const&, Catch::AssertionReaction&) | void RunContext::handleMessage(
AssertionInfo const& info,
ResultWas::OfType resultType,
StringRef const& message,
AssertionReaction& reaction
) {
m_reporter->assertionStarting( info );
m_lastAssertionInfo = info;
AssertionResultData data( re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movq 0x128(%rdi), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movl 0x30(%r12), %eax
movl %eax, 0x190(%r14)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
mov... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::rngSeed() | unsigned int rngSeed() {
return getCurrentContext().getConfig()->rngSeed();
} | pushq %rax
movq 0x874d6(%rip), %rdi # 0xaaac0
testq %rdi, %rdi
je 0x235f4
movq (%rdi), %rax
jmp 0x23628
movl $0x30, %edi
callq 0x12620
movq %rax, %rdi
leaq 0x82488(%rip), %rax # 0xa5a90
movq %rax, (%rdi)
leaq 0x824ce(%rip), %rcx # 0xa5ae0
movq %rcx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movu... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Section::~Section() | Section::~Section() {
if( m_sectionIncluded ) {
SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
if( uncaught_exceptions() )
getResultCapture().sectionEndedEarly( endInfo );
else
getResultCapture().sectionEnded( endI... | pushq %rbx
movq %rdi, %rbx
callq 0x23736
movl $0xa0, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x12650
nop
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Session::showHelp() const | void Session::showHelp() const {
Catch::cout()
<< "\nCatch v" << libraryVersion() << "\n"
<< m_cli << std::endl
<< "For more detailed usage please see the project docs\n" << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x85f1a(%rip), %rbx # 0xa9f88
leaq 0x535b8(%rip), %rsi # 0x7762d
movl $0x8, %edx
movq %rbx, %rdi
callq 0x12710
callq 0x24210
leaq 0x86e3a(%rip), %rsi # 0xaaec8
movq %rbx, %rdi
callq 0x24125
leaq 0x53b34(%rip), %rsi # 0x77bd1
movl $0x1, %edx
movq %rbx... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Session::run() | int Session::run() {
if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
static_cast<void>(std::getchar());
}
int exitCode = runInternal();
if( ( m_configData.wa... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testb $0x1, 0xc0(%rdi)
je 0x247ad
movq 0x8581b(%rip), %rbx # 0xa9f88
leaq 0x52f87(%rip), %rsi # 0x776fb
movl $0x2c, %edx
movq %rbx, %rdi
callq 0x12710
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x125f0
movsbl %al, %esi
movq %rb... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::ReusableStringStream::ReusableStringStream() | ReusableStringStream::ReusableStringStream()
: m_index( Singleton<StringStreams>::getMutable().add() ),
m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
{} | pushq %rbx
movq %rdi, %rbx
leaq 0x80bc5(%rip), %rax # 0xa6118
movq %rax, (%rdi)
callq 0x5f8c8
leaq 0x8(%rax), %rdi
callq 0x3f6ea
movq %rax, 0x8(%rbx)
callq 0x5f8c8
movq 0x8(%rbx), %rcx
movq 0x8(%rax), %rax
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rbx)
popq %rbx
retq
nop
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::StringRef::c_str() const | constexpr auto isNullTerminated() const noexcept -> bool {
return m_start[m_size] == '\0';
} | pushq %rbx
subq $0x40, %rsp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x259ac
addq $0x40, %rsp
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x25548
movq 0x10(%rbx), %rbx
leaq 0x51dc0(%rip), %rsi # 0x77784
movl $0x3b, %edx
movq %rbx, %rdi
callq 0x12710
addq $0x8, %rbx
leaq 0x8(%... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::RegistrarForTagAliases::RegistrarForTagAliases(char const*, char const*, Catch::SourceLineInfo const&) | RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
CATCH_TRY {
getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
callq 0x3c4b8
movq %rax, %r14
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r12, %rsi
callq 0x3dcde
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
movq %r15, %rsi
callq 0x3dcde
addq $0x8, %r14
movq (%r14), %rax
le... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::TagAliasRegistry::expandAliases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
std::string expandedTestSpec = unexpandedTestSpec;
for( auto const& registryKvp : m_registry ) {
std::size_t pos = expandedTestSpec.find( registryKvp.first );
if( pos != std::string::npos... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x4e2ce
movq 0x20(%r14), %r15
addq $0x10, %r14
cmpq %r14, %r15
je 0x25dec
leaq 0x1... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::(anonymous namespace)::parseSpecialTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
if( startsWith( tag, '.' ) ||
tag == "!hide" )
return TestCaseInfo::IsHidden;
else if( tag == "!throws" )
return TestCaseInfo::Throws;
else if( tag == "!shouldf... | pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x266b2
movq (%rbx), %rcx
movl $0x2, %eax
cmpb $0x2e, (%rcx)
je 0x2674f
leaq 0x5117b(%rip), %rsi # 0x77834
movq %rbx, %rdi
callq 0x12190
testl %eax, %eax
je 0x2672e
leaq 0x52751(%rip), %rsi # 0x78e1d
movq %rbx, %rdi
callq 0x12190
testl %eax, %eax
je 0x26735
lea... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::TestCase::withName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | TestCase TestCase::withName( std::string const& _newName ) const {
TestCase other( *this );
other.name = _newName;
return other;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3e79e
movq 0xa8(%r15), %rax
movq %rax, 0xa8(%rbx)
movq 0xb0(%r15), %rax
movq %rax, 0xb0(%rbx)
testq %rax, %rax
je 0x26ba9
movq 0x833e5(%rip), %rcx # 0xa9f80
cmpb $0x0, (%rcx)
je 0x26ba5
incl 0x8(%rax)
jmp 0x26ba9
lock
incl 0x8(... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::extractClassName[abi:cxx11](Catch::StringRef const&) | std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
std::string className(classOrQualifiedMethodName);
if( startsWith( className, '&' ) )
{
std::size_t lastColons = className.rfind( "::" );
std::size_t penultimateColons = className.rfind( "::", l... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x10(%rdi), %r12
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %r12, (%rdi)
movq %rax, %rsi
callq 0x42cf6
cmpq $0x0, 0x8(%rbx)
je 0x27570
movq (%rbx), %rax
cmpb $0x26, (%rax)
jne 0x27570
leaq 0x503a0(%rip), %r14 # 0x7789... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::TestCaseTracking::TrackerBase::fail() | void TrackerBase::fail() {
m_runState = Failed;
if( m_parent )
m_parent->markAsNeedingAnotherRun();
moveToParent();
m_ctx.completeCycle();
} | pushq %rbx
movq %rdi, %rbx
movl $0x5, 0x60(%rdi)
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x27bc4
movq (%rdi), %rax
callq *0x50(%rax)
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x27bc4
movq 0x38(%rbx), %rcx
movq %rax, 0x10(%rcx)
movl $0x2, 0x18(%rcx)
popq %rbx
retq
leaq 0x4fcd7(%rip), %rdi # 0x778a2
leaq 0x4f3af(%r... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::TestSpec::Filter::matches(Catch::TestCaseInfo const&) const | bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
return std::all_of( m_patterns.begin(), m_patterns.end(), [&]( PatternPtr const& p ){ return p->matches( testCase ); } );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r13
movq 0x8(%rdi), %r14
movq %r14, %r15
subq %r13, %r15
movq %r15, %rbp
sarq $0x6, %rbp
testq %rbp, %rbp
jle 0x2841e
incq %rbp
addq $0x20, %r13
movq %r13, %r12
movq -0x20(%r12), %rdi
movq (%rdi), %rax
movq %rbx, ... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::TestSpecParser::processNoneChar(char) | bool TestSpecParser::processNoneChar( char c ) {
switch( c ) {
case ' ':
return true;
case '~':
m_exclusion = true;
return false;
case '[':
startNewMode( Tag );
return false;
case '"':
startNewMode( QuotedNam... | cmpl $0x5a, %esi
jg 0x289ed
cmpl $0x20, %esi
je 0x28a05
cmpl $0x22, %esi
jne 0x289fd
movl $0x2, (%rdi)
jmp 0x28a0e
cmpl $0x5b, %esi
je 0x28a08
cmpl $0x7e, %esi
jne 0x289fd
movb $0x1, 0x8(%rdi)
jmp 0x28a0e
movl $0x1, (%rdi)
jmp 0x28a0e
movb $0x1, %al
retq
movl $0x3, (%rdi)
xorl %eax, %eax
retq
nop
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::TestSpecParser::isControlChar(char) const | bool TestSpecParser::isControlChar( char c ) const {
switch( m_mode ) {
default:
return false;
case None:
return c == '~';
case Name:
return c == '[';
case EscapedName:
return true;
case Q... | movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x28adf
leaq 0x4c703(%rip), %rcx # 0x751b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x7e, %sil
jmp 0x28adb
movb $0x1, %al
retq
cmpb $0x22, %sil
jmp 0x28adb
addb $-0x5b, %sil
testb $-0x3, %sil
jmp 0x28adb
cmpb $0x5b, %sil
sete %al
retq
xorl %eax, %eax
retq
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::TestSpecParser::addTagPattern() | void TestSpecParser::addTagPattern() {
auto token = preprocessPattern();
if (!token.empty()) {
// If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
// we have to create a separate hide tag and shorten the real one
if (token.size() > 1 && token[0] == '.... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28e54
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x28dc8
cmpq $0x1, %rax
je 0x28d22
movq 0x38(%rsp), %rax
cmpb $0x2e, (%rax)
jne 0x28d22
leaq 0x38(%rsp), %rdi
movl $0x1, %edx
xorl %esi, %esi
callq 0x12750
... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::StringMaker<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>::convert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string StringMaker<std::string>::convert(const std::string& str) {
if (!getCurrentContext().getConfig()->showInvisibles()) {
return '"' + str + '"';
}
std::string s("\"");
for (char c : str) {
switch (c) {
case '\n':
s.append("\\n");
break;
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8168d(%rip), %rdi # 0xaaac0
testq %rdi, %rdi
je 0x2943d
movq (%rdi), %rax
jmp 0x29471
movl $0x30, %edi
callq 0x12620
movq %rax, %rdi
leaq 0x7c63f(%rip), %rax # 0xa5a90
movq %rax, (%rdi)
leaq... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.