name string | code string | asm string | file string |
|---|---|---|---|
testing::internal::FormatCompilerIndependentFileLocation[abi:cxx11](char const*, int) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
const char* file, int line) {
const std::string file_name(file == nullptr ? kUnknownFile : file);
if (line < 0)
return file_name;
else
return file_name + ":" + StreamableToString(line);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, -0x1c(%rbp)
testq %rsi, %rsi
leaq 0x1ddb6(%rip), %rax # 0x38900
cmoveq %rax, %r14
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x8230
leaq (%rax,%r14), %rdx
leaq -0x80(%rbp)... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestProperties(std::ostream*, testing::TestResult const&) | void XmlUnitTestResultPrinter::OutputXmlTestProperties(
std::ostream* stream, const TestResult& result) {
const std::string kProperties = "properties";
const std::string kProperty = "property";
if (result.test_property_count() <= 0) {
return;
}
*stream << "<" << kProperties << ">\n";
for (int i = ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x80(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x1fa95(%rip), %rsi # 0x3a7d0
leaq 0x1fa98(%rip), %rdx # 0x3a7da
leaq -0x90(%rbp), %rdi
callq 0x3470e
leaq -0xa0(%rbp), %rax
movq ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream*, testing::TestSuite const&) | void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
const TestSuite& test_suite) {
const std::string kTestsuite = "testsuite";
*stream << " <" << kTestsuite;
OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());
OutputXmlAttribute... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x80(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1f5c6(%rip), %rsi # 0x3a668
leaq 0x1f5c8(%rip), %rdx # 0x3a671
leaq -0x90(%rbp), %rdi
callq 0x3470e
leaq 0x1f6cf(%rip), %rsi ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes[abi:cxx11](testing::TestResult const&) | std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
const TestResult& result) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << " " << property.key() << "="
<< "\"" << EscapeXmlA... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xf840
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
testl %eax, %eax
jle 0x1b7ee
movq -0x38(%rbp), %r15
addq $0x10, %r15
xorl %r12d, %r12d... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(char const*) | JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(const char* output_file)
: output_file_(output_file) {
if (output_file_.empty()) {
GTEST_LOG_(FATAL) << "JSON output file may not be null";
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x30655(%rip), %rax # 0x4bf18
movq %rax, (%rdi)
addq $0x8, %rdi
leaq -0x11(%rbp), %rdx
callq 0x2d590
cmpq $0x0, 0x10(%rbx)
jne 0x1b915
leaq 0x1dfcb(%rip), %rdx # 0x398ac
leaq -0x18(%rbp), %rdi
movl $0x3, %esi
movl $0x118e, %e... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* jsonout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintJsonUnitTest(&stream, unit_test);
fprintf(jsonout, "%s", StringStreamToString(&str... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
addq $0x8, %rdi
callq 0x1742c
movq %rax, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x8370
leaq -0x1a8(%rbp), %rdi
movq %r14, %rsi
callq 0x1ba1c
leaq -0x30(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xfac9
leaq -0x20(%rbp... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream*, testing::UnitTest const&) | void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
const UnitTest& unit_test) {
const std::string kTestsuites = "testsuites";
const std::string kIndent = Indent(2);
*stream << "{\n";
OutputJsonKey(stream, kTestsuites, "tests", unit_test.rep... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, %r14
leaq -0xa0(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x1ed4b(%rip), %rsi # 0x3a794
leaq 0x1ed4e(%rip), %rdx # 0x3a79e
leaq -0xb0(%rbp), %rdi
callq 0x3470e
leaq -0x60(%rbp), %ra... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::EscapeJson(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) {
Message m;
for (size_t i = 0; i < str.size(); ++i) {
const char ch = str[i];
switch (ch) {
case '\\':
case '"':
case '/':
m << '\\' << ch;
break;
case '\b':
m << "\\b";
break;... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf840
cmpq $0x0, 0x8(%r14)
je 0x1c24b
movq -0x30(%rbp), %r15
addq $0x10, %r15
xorl %ebx, %ebx
leaq -0x50(%rbp), %r12
movq %r15, -0x58(%rbp)
movq %r15, %... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(std::ostream*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator... | void JsonUnitTestResultPrinter::OutputJsonKey(
std::ostream* stream,
const std::string& element_name,
const std::string& name,
const std::string& value,
const std::string& indent,
bool comma) {
const std::vector<std::string>& allowed_names =
GetReservedOutputAttributesForElement(element_... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, -0x2c(%rbp)
movq %r8, %r13
movq %rcx, -0x58(%rbp)
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x1918d
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r12, %rdx
call... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(std::ostream*, testing::TestResult const&) | void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(
::std::ostream* stream, const TestResult& result) {
// Output the boilerplate for a new test suite.
*stream << Indent(4) << "{\n";
OutputJsonKey(stream, "testsuite", "name", "NonTestSuiteFailure", Indent(6));
OutputJsonKey(stream, "testsuite"... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, %rbx
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq -0x48(%rbp), %r15
movl $0x4, %esi
movq %r15, %rdi
movl $0x20, %edx
callq 0x8650
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::FormatTimeInMillisAsDuration[abi:cxx11](long) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
::std::stringstream ss;
ss << (static_cast<double>(ms) * 1e-3) << "s";
return ss.str();
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x198(%rbp), %rdi
callq 0x8370
leaq -0x188(%rbp), %rdi
cvtsi2sd %r14, %xmm0
mulsd 0x1af9c(%rip), %xmm0 # 0x38658
callq 0x8970
leaq 0x1d58d(%rip), %rsi # 0x3ac55
movl $0x1, %edx
movq %... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::FormatEpochTimeInMillisAsRFC3339[abi:cxx11](long) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
struct tm time_struct;
if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
return "";
// YYYY-MM-DDThh:mm:ss
return StreamableToString(time_struct.tm_year + 1900) + "-" +
String::FormatIntWidth2(time_struct.tm_mon... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rsi, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
leaq -0x68(%rbp), %rdi
mov... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonTestResult(std::ostream*, testing::TestResult const&) | void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream,
const TestResult& result) {
const std::string kIndent = Indent(10);
int failures = 0;
for (int i = 0; i < result.total_part_count(); ++i) {
const TestPartResult& part = result.Get... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq -0x50(%rbp), %rdi
movl $0xa, %esi
movl $0x20, %edx
callq 0x8650
movq 0x40(%r14), %rax
subq 0x38(%r14), %rax
shrq $0x4, %rax
imull $... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::StreamingListener::UrlEncode[abi:cxx11](char const*) | std::string StreamingListener::UrlEncode(const char* str) {
std::string result;
result.reserve(strlen(str) + 1);
for (char ch = *str; ch != '\0'; ch = *++str) {
switch (ch) {
case '%':
case '=':
case '&':
case '\n':
result.append("%" + String::FormatByte(static_cast<unsigned ch... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x8230
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x8930
leaq... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::StreamingListener::SocketWriter::MakeConnection() | void StreamingListener::SocketWriter::MakeConnection() {
GTEST_CHECK_(sockfd_ == -1)
<< "MakeConnection() can't be called when there is already a connection.";
addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses.
hints.ai_socktype =... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
je 0x1fd21
leaq 0x19bd7(%rip), %rdx # 0x398ac
leaq -0x60(%rbp), %rdi
movl $0x3, %esi
movl $0x131d, %ecx # imm = 0x131D
callq 0x2a45a
movq 0x2d2f9(%rip), %rdi # 0x4cfe8
leaq 0x1abc8(%rip),... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestEventListeners::SetDefaultXmlGenerator(testing::TestEventListener*) | void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
if (default_xml_generator_ != listener) {
// It is an error to pass this method a listener that is already in the
// list.
delete Release(default_xml_generator_);
default_xml_generator_ = listener;
if (listener != nullp... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
cmpq %rbx, %rsi
je 0x20056
movq %rdi, %r14
xorl %eax, %eax
cmpq %rsi, 0x8(%rdi)
setne %al
movq $0x0, 0x8(%rdi,%rax,8)
movq (%rdi), %rdi
callq 0x16dc2
testq %rax, %rax
je 0x2003e
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::UnitTest::test_case_to_run_count() const | int UnitTest::test_case_to_run_count() const {
return impl()->test_suite_to_run_count();
} | pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rax
movq 0xb8(%rax), %rcx
movq 0xc0(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x200f6
movq (%rcx), %rsi
movzbl 0x70(%rsi), %esi
addl %esi, %eax
addq $0x8, %rcx
jmp 0x200e2
popq %rbp
retq
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::UnitTest::total_test_count() const | int UnitTest::total_test_count() const { return impl()->total_test_count(); } | pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rax
movq 0xb8(%rax), %rcx
movq 0xc0(%rax), %rdx
subq %rcx, %rdx
je 0x2014e
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
xorl %eax, %eax
movq (%rcx,%rsi,8), %rdi
movq 0x38(%rdi), %r8
subq 0x30(%rdi), %r8
shrq $0x3, %r8
addl %r8d, %eax
incq %rsi
cmpq %rsi, %... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::UnitTest::Failed() const | bool UnitTest::Failed() const { return impl()->Failed(); } | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x40(%rdi), %rbx
movq %rbx, %rdi
callq 0xf088
testl %eax, %eax
jle 0x20171
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x178, %rbx # imm = 0x178
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x131a6
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::UnitTest::GetTestCase(int) const | inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
: v[static_cast<size_t>(i)];
} | testl %esi, %esi
js 0x201c4
pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rax
movq 0xd0(%rax), %rcx
movq 0xd8(%rax), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x201c0
movl %esi, %edx
cmpl $0x0, (%rcx,%rdx,4)
js 0x201c0
movq 0xb8(%rax), %rax
movq (%rax,%rdx,8), %rax
jmp 0x201c2
xorl %eax, %eax
popq %rbp
re... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h |
testing::UnitTest::GetMutableTestSuite(int) | TestSuite* UnitTest::GetMutableTestSuite(int i) {
return impl()->GetMutableSuiteCase(i);
} | pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
testl %esi, %esi
js 0x201f7
movq 0xd0(%rax), %rdx
movq 0xd8(%rax), %rdi
subq %rdx, %rdi
shrq $0x2, %rdi
cmpl %esi, %edi
jle 0x201f7
movl %esi, %ecx
movl (%rdx,%rcx,4), %ecx
testl %ecx, %ecx
js 0x2020a
movl %ecx, %ecx
movq 0... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::UnitTest::AddEnvironment(testing::Environment*) | Environment* UnitTest::AddEnvironment(Environment* env) {
if (env == nullptr) {
return nullptr;
}
impl_->environments().push_back(env);
return env;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rsi, -0x8(%rbp)
testq %rsi, %rsi
je 0x20240
movq 0x40(%rdi), %rdi
movq 0xa8(%rdi), %rax
cmpq 0xb0(%rdi), %rax
je 0x20244
movq %rsi, (%rax)
addq $0x8, 0xa8(%rdi)
jmp 0x20257
xorl %eax, %eax
jmp 0x2025b
addq $0xa0, %rdi
leaq -0x8(%rbp), %rdx
movq %rax, %rsi
callq 0x36c9c
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::RunAllTests() | bool UnitTestImpl::RunAllTests() {
// True if and only if Google Test is initialized before RUN_ALL_TESTS() is
// called.
const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
// Do not run any test if the --help flag was specified.
if (g_help_flag)
return true;
// Repeats the c... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x2d7a5(%rip), %rsi # 0x4dba0
leaq -0x78(%rbp), %r14
movq %r14, %rdi
callq 0x2d744
movq (%r14), %r15
movq 0x8(%r14), %r13
movq %r14, %rdi
callq 0x2d6da
movb $0x1, %r14b
cmpb $0x0, 0x2d6b1(%rip) ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::UnitTest::current_test_suite() const | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
return impl_->current_test_suite();
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x31ca6
movq 0x40(%rbx), %rax
movq 0x168(%rax), %rbx
movq %r14, %rdi
callq 0x31d4c
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x2d7d8
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::UnitTest::current_test_case() const | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
return impl_->current_test_suite();
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x31ca6
movq 0x40(%rbx), %rax
movq 0x168(%rax), %rbx
movq %r14, %rdi
callq 0x31d4c
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x2d7d8
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::UnitTest::current_test_info() const | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
return impl_->current_test_info();
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x31ca6
movq 0x40(%rbx), %rax
movq 0x170(%rax), %rbx
movq %r14, %rdi
callq 0x31d4c
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x2d7d8
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::UnitTest::PopGTestTrace() | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
impl_->gtest_trace_stack().pop_back();
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x31ca6
movl $0x248, %edi # imm = 0x248
addq 0x40(%r14), %rdi
callq 0x3247c
movq 0x8(%rax), %rcx
leaq -0x30(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq -0x20(%rcx), %rdi
addq $-0x10, %rcx
cmpq %rcx, %rdi
je ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::UnitTestImpl(testing::UnitTest*) | UnitTestImpl::UnitTestImpl(UnitTest* parent)
: parent_(parent),
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
default_global_test_part_result_reporter_(this),
default_per_thread_test_part_result_reporter_(this),
GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x2b387(%rip), %rax # 0x4bfd8
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
leaq 0x20(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
leaq 0x30(%rdi),... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::ConfigureXmlOutput() | void UnitTestImpl::ConfigureXmlOutput() {
const std::string& output_format = UnitTestOptions::GetOutputFormat();
if (output_format == "xml") {
listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
} else if (output_format == "json")... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0xd46a
leaq 0x17691(%rip), %rsi # 0x3882c
movq %r14, %rdi
callq 0x8170
testl %eax, %eax
je 0x21243
leaq 0x1983e(%rip), %rsi # 0x3a9f0
leaq -0x58(%rbp), %rdi
callq 0x8170
test... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::PostFlagParsingInit() | void UnitTestImpl::PostFlagParsingInit() {
// Ensures that this function does not execute more than once.
if (!post_flag_parse_init_performed_) {
post_flag_parse_init_performed_ = true;
#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
// Register to send notifications about key process state changes.
lis... | cmpb $0x0, 0x218(%rdi)
je 0x21528
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x218(%rdi)
leaq 0x238(%rdi), %r14
callq 0x28af7
movq %r14, %rdi
movq %rax, %rsi
callq 0x34078
cmpq $0x0, 0x238(%rbx)
je 0x21565
movq 0x1f8(%rbx), %rax
movb $0x0, 0x8(%rax)
movq %rbx, %rdi
callq 0x146e6
mo... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::GetTestSuite(char const*, char const*, void (*)(), void (*)()) | TestSuite* UnitTestImpl::GetTestSuite(
const char* test_suite_name, const char* type_param,
internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc) {
// Can we find a TestSuite with the given name?
const auto test_suite =
std::find_if(test_suites_.rbegin(), test_suite... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, -0x70(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movq 0xc0(%rdi), %rax
movq %rax, -0x80(%rbp)
movq 0xb8(%rdi), %rax
movq %rax, -0x78(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::WriteToShardStatusFileIfNeeded() | void WriteToShardStatusFileIfNeeded() {
const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
if (test_shard_file != nullptr) {
FILE* const file = posix::FOpen(test_shard_file, "w");
if (file == nullptr) {
ColoredPrintf(GTestColor::kRed,
"Could not write to the t... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x17050(%rip), %rdi # 0x38850
callq 0x86e0
testq %rax, %rax
je 0x2182f
movq %rax, %rbx
leaq 0x19326(%rip), %rsi # 0x3ab3a
movq %rax, %rdi
callq 0x8680
testq %rax, %rax
je 0x21836
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x84e0
addq $0x8, %rsp
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::FilterTests(testing::internal::UnitTestImpl::ReactionToSharding) | int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
// num_... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %r12d
movq %rdi, %rbx
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
testl %esi, %esi
jne 0x218a9
leaq 0x16f54(%rip), %rdi # 0x387f0
movl $0xffffffff, %esi... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::ListTestsMatchingFilter() | void UnitTestImpl::ListTestsMatchingFilter() {
// Print at most this many characters for each type/value parameter.
const int kMaxParamLength = 250;
for (auto* test_suite : test_suites_) {
bool printed_test_suite_name = false;
for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
cons... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq 0xb8(%rdi), %rbx
movq %rdi, -0x78(%rbp)
movq 0xc0(%rdi), %rax
movq %rax, -0x80(%rbp)
cmpq %rax, %rbx
je 0x21bf3
movq (%rbx), %r12
movq 0x30(%r12), %rax
cmpq %rax, 0x38(%r12)
je 0x21be5
xorl ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::ShuffleTests() | void UnitTestImpl::ShuffleTests() {
// Shuffles the death test suites.
ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);
// Shuffles the non-death test suites.
ShuffleRange(random(), last_death_test_suite_ + 1,
static_cast<int>(test_suites_.size()), &test_suite_indices... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x220(%rdi), %rbx
movl 0x164(%rdi), %edx
incl %edx
leaq 0xd0(%rdi), %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x301a4
movl 0x164(%r14), %esi
incl %esi
movq 0xc0(%r14), %rdx
subq 0xb8(%r14), %rdx
shrq $0x3, %rdx
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::UnshuffleTests() | void UnitTestImpl::UnshuffleTests() {
for (size_t i = 0; i < test_suites_.size(); i++) {
// Unshuffles the tests in each test suite.
test_suites_[i]->UnshuffleTests();
// Resets the index of each test suite.
test_suite_indices_[i] = static_cast<int>(i);
}
} | movq 0xb8(%rdi), %rax
movq 0xc0(%rdi), %rcx
subq %rax, %rcx
je 0x21fec
pushq %rbp
movq %rsp, %rbp
sarq $0x3, %rcx
movq 0xd0(%rdi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movq (%rax,%rsi,8), %r8
movq 0x48(%r8), %rdi
movq 0x50(%r8), %r8
subq %rdi, %r8
je 0x21fe0
sarq $0x2, %r8
cmpq $0x1, %r8
adcq $0x0, %r8
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::ParseInt32(testing::Message const&, char const*, int*) | bool ParseInt32(const Message& src_text, const char* str, int32_t* value) {
// Parses the environment variable as a decimal integer.
char* end = nullptr;
const long long_value = strtol(str, &end, 10); // NOLINT
// Has strtol() consumed all characters in the string?
if (*end != '\0') {
// No - an invalid... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq -0x50(%rbp), %r15
movq $0x0, (%r15)
movq %rsi, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x8820
movq (%r15), %rcx
cmpb $0x0, (%rcx)
je 0x220c4
leaq -0x48(%rbp), %r14
movq %r14, %... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc |
testing::internal::PrintOnOneLine(char const*, int) | static void PrintOnOneLine(const char* str, int max_length) {
if (str != nullptr) {
for (int i = 0; *str != '\0'; ++str) {
if (i >= max_length) {
printf("...");
break;
}
if (*str == '\n') {
printf("\\n");
i += 2;
} else {
printf("%c", *str);
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x222df
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x222df
incq %rbx
leaq 0x18577(%rip), %r14 # 0x3a81c
xorl %r15d, %r15d
cmpl $0xfa, %r15d
jae 0x222ea
cmpb $0xa, %al
jne 0x222c6
movq %r14, %rdi
xorl %eax, %eax
callq ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::ParseInt32Flag(char const*, char const*, int*) | bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag, false);
// Aborts if the parsing failed.
if (value_str == nullptr) return false;
// Sets *value to the value of the flag.
return Parse... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
xorl %r13d, %r13d
xorl %edx, %edx
callq 0x22461
testq %rax, %rax
je 0x22436
movq %rax, %r15
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0xf840
movq (%rbx), %rbx
leaq 0x10(%rbx), %r13
leaq 0x1887... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::ParseFlagValue(char const*, char const*, bool) | static const char* ParseFlagValue(const char* str, const char* flag,
bool def_optional) {
// str and flag must not be NULL.
if (str == nullptr || flag == nullptr) return nullptr;
// The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
const std::string flag_str = std:... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x22489
xorl %ebx, %ebx
jmp 0x225d9
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x187c8(%rip), %r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TempDir[abi:cxx11]() | std::string TempDir() {
#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
#elif GTEST_OS_WINDOWS_MOBILE
return "\\temp\\";
#elif GTEST_OS_WINDOWS
const char* temp_dir = internal::posix::GetEnv("TEMP");
if (temp_dir == nullptr || temp_dir[0] == '\0') {
return "\\temp\\";
... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x185e5(%rip), %rdi # 0x3ac72
callq 0x86e0
testq %rax, %rax
je 0x226bc
movq %rax, %r14
cmpb $0x0, (%rax)
je 0x226bc
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x8230
movq %r14, %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %r14, %r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::InDeathTestChild() | bool InDeathTestChild() {
# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
// On Windows and Fuchsia, death tests are thread-safe regardless of the value
// of the death_test_style flag.
return !GTEST_FLAG(internal_run_death_test).empty();
# else
if (GTEST_FLAG(death_test_style) == "threadsafe")
return !GTEST_F... | pushq %rbp
movq %rsp, %rbp
leaq 0x2b49e(%rip), %rdi # 0x4dc30
leaq 0x184eb(%rip), %rsi # 0x3ac84
callq 0x8170
xorl %ecx, %ecx
cmpq $0x0, 0x2b470(%rip) # 0x4dc18
setne %cl
testl %eax, %eax
movzbl 0x2b49d(%rip), %eax # 0x4dc51
cmovel %ecx, %eax
andb $0x1, %al
popq %rbp
retq
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestAbort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static void DeathTestAbort(const std::string& message) {
// On a POSIX system, this function may be called from a threadsafe-style
// death test child process, which operates on a very small stack. Use
// the heap for any additional non-minuscule memory requirements.
const InternalRunDeathTestFlag* const flag ... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xb8c6
movq 0x2b31e(%rip), %rax # 0x4dc00
movq 0x238(%rax), %rax
testq %rax, %rax
jne 0x2290d
movq 0x2a6c3(%rip), %r14 # 0x4cfb8
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x85e0
movq (%r14), %rdi
callq 0x8670
callq 0x2ea5f
movl 0x28(%rax), %... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc |
testing::internal::DeathTest::Create(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>, char const*, int, testing::internal::DeathTest**) | bool DeathTest::Create(const char* statement,
Matcher<const std::string&> matcher, const char* file,
int line, DeathTest** test) {
return GetUnitTestImpl()->death_test_factory()->Create(
statement, std::move(matcher), file, line, test);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0xb8c6
movq 0x2b28a(%rip), %rax # 0x4dc00
movq 0x240(%rax), %rdi
leaq 0x2a0bc(%rip), %rax # 0x4ca40
leaq -0x40(%rbp), %rdx
movq... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc |
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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, %rbx
leaq -0x29(%rbp), %r14
movl 0x34(%rbx), %edi
movl $0x1, %edx
movq %r14, %rsi
callq 0x8840
movq %rax, %r15
cmpl $-0x1, %r15d
jne 0x22a63
callq 0x8070
cmpl $0x4, (%rax)
je 0x22a2f
l... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::Abort(testing::internal::DeathTest::AbortReason) | void DeathTestImpl::Abort(AbortReason reason) {
// The parent process considers the death test to be a failure if
// it finds any data in our pipe. So, here we write a single flag byte
// to the pipe, then exit.
const char status_ch =
reason == TEST_DID_NOT_DIE ? kDeathTestLived :
reason == TEST_TH... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %rbx
cmpl $0x1, %esi
sete %al
addb %al, %al
addb $0x52, %al
cmpl $0x2, %esi
movzbl %al, %eax
movl $0x4c, %ecx
cmovnel %eax, %ecx
leaq -0x29(%rbp), %r14
movb %cl, (%r14)
movl 0x38(%rbx)... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::Passed(bool) | bool DeathTestImpl::Passed(bool status_ok) {
if (!spawned())
return false;
const std::string error_message = GetErrorLogs();
bool success = false;
Message buffer;
buffer << "Death test: " << statement() << "\n";
switch (outcome()) {
case LIVED:
buffer << " Result: failed to die.\n"
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
cmpb $0x1, 0x28(%rdi)
jne 0x236f8
movl %esi, %r15d
movq %rdi, %r14
movq (%rdi), %rax
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
callq *0x30(%rax)
leaq -0x48(%rbp), %rdi
callq 0xf840
movq -0x48(%rbp), %rbx
addq ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc |
testing::internal::ForkingDeathTest::ForkingDeathTest(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>) | ForkingDeathTest::ForkingDeathTest(const char* a_statement,
Matcher<const std::string&> matcher)
: DeathTestImpl(a_statement, std::move(matcher)), child_pid_(-1) {} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28be2(%rip), %r15 # 0x4ca40
movq %r15, -0x38(%rbp)
movq 0x8(%rdx), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rdx), %rax
movq %rax, -0x28(%rbp)
movq $0x0, 0x8(%rdx)
leaq 0x28857(%rip), %r12 ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
xorl %eax, %eax
cmpb $0x1, 0x28(%rdi)
jne 0x23faa
movq %rdi, %rbx
callq 0x22a14
leaq -0x2c(%rbp), %r14
movl 0x3c(%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x8400
cmpl $-0x1, %eax
jne 0x23... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc |
testing::internal::ParseInternalRunDeathTestFlag() | InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
if (GTEST_FLAG(internal_run_death_test) == "") return nullptr;
// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
// can use it here.
int line = -1;
int index = -1;
::std::vector< ::std::string> fields;
SplitString(GTEST_FLAG(inte... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
leaq 0x25103(%rip), %rdi # 0x4dc10
leaq 0x1199d(%rip), %rsi # 0x3a4b1
callq 0x8170
testl %eax, %eax
je 0x28c26
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
movl %eax, -0x28(%rbp)
xorps %xmm0, %xmm0
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc |
testing::internal::FilePath::GetCurrentDir() | FilePath FilePath::GetCurrentDir() {
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_ESP32 || \
GTEST_OS_XTENSA
// These platforms do not have a current directory, so we just return
// something reasonable.
return FilePath(kCurrentDire... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1030, %rsp # imm = 0x1030
movq %rdi, %rbx
leaq -0x1050(%rbp), %r14
movl $0x1001, %edx # imm = 0x1001
movq %r14, %rdi
xorl %esi, %esi
callq 0x82e0
movl $0x1001, %esi # imm = 0x1001
movq %r14, %rdi
callq 0x8280
te... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::FindLastPathSeparator() const | const char* FilePath::FindLastPathSeparator() const {
const char* const last_sep = strrchr(c_str(), kPathSeparator);
#if GTEST_HAS_ALT_PATH_SEP_
const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator);
// Comparing two pointers of which only one is NULL is undefined.
if (last_alt_sep != nullp... | pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdi
movl $0x2f, %esi
popq %rbp
jmp 0x85c0
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::RemoveFileName() const | FilePath FilePath::RemoveFileName() const {
const char* const last_sep = FindLastPathSeparator();
std::string dir;
if (last_sep) {
dir = std::string(c_str(), static_cast<size_t>(last_sep + 1 - c_str()));
} else {
dir = kCurrentDirectoryString;
}
return FilePath(dir);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
movq %r14, %rdi
movl $0x2f, %esi
callq 0x85c0
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
testq %rax, %rax
je 0x28f98
incq %rax
leaq -0x50(%rbp), %r12
movq ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::RemoveTrailingPathSeparator() const | FilePath FilePath::RemoveTrailingPathSeparator() const {
return IsDirectory()
? FilePath(pathname_.substr(0, pathname_.length() - 1))
: *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x29043
movq (%rsi), %rax
cmpb $0x2f, -0x1(%rax,%rcx)
sete %r15b
jmp 0x29046
xorl %r15d, %r15d
testb %r15b, %r15b
je 0x2907f
decq %rcx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
xorl %edx, %... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::FileOrDirectoryExists() const | bool FilePath::FileOrDirectoryExists() const {
#if GTEST_OS_WINDOWS_MOBILE
LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
const DWORD attributes = GetFileAttributes(unicode);
delete [] unicode;
return attributes != kInvalidFileAttributes;
#else
posix::StatStruct file_stat{};
return posix::Stat(pa... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq -0xa0(%rbp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x82e0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x8470
testl %eax, %eax
sete %al
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::DirectoryExists() const | bool FilePath::DirectoryExists() const {
bool result = false;
#if GTEST_OS_WINDOWS
// Don't strip off trailing separator if path is a root directory on
// Windows (like "C:\\").
const FilePath& path(IsRootDirectory() ? *this :
RemoveTrailingPathSeparator());
#else
co... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq -0xa0(%rbp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x82e0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x8470
movl 0x18(%r14), %ecx
andl $0xf000, %ecx # imm = 0xF000
xorl $0x4000, %ecx # imm = 0x4... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::CreateDirectoriesRecursively() const | bool FilePath::CreateDirectoriesRecursively() const {
if (!this->IsDirectory()) {
return false;
}
if (pathname_.length() == 0 || this->DirectoryExists()) {
return true;
}
const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
return parent.CreateDirectoriesRecursively() && th... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x29254
movq %rdi, %rbx
sete %cl
movq (%rdi), %rdx
cmpb $0x2f, -0x1(%rdx,%rax)
sete %r14b
setne %al
orb %cl, %al
jne 0x2927b
leaq -0xc0(%rbp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x82e0
mov... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::CreateFolder() const | bool FilePath::CreateFolder() const {
#if GTEST_OS_WINDOWS_MOBILE
FilePath removed_sep(this->RemoveTrailingPathSeparator());
LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
int result = CreateDirectory(unicode, nullptr) ? 0 : -1;
delete [] unicode;
#elif GTEST_OS_WINDOWS
int result = _mkdir(pathna... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1ff, %esi # imm = 0x1FF
callq 0x8240
movl %eax, %ecx
movb $0x1, %al
cmpl $-0x1, %ecx
jne 0x29327
leaq -0xa0(%rbp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x82e0
movq (%rbx), %rdi
m... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::Normalize() | void FilePath::Normalize() {
auto out = pathname_.begin();
for (const char character : pathname_) {
if (!IsPathSeparator(character)) {
*(out++) = character;
} else if (out == pathname_.begin() || *std::prev(out) != kPathSeparator) {
*(out++) = kPathSeparator;
} else {
continue;
}
... | pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x29371
xorl %esi, %esi
movq %rax, %rdx
movb (%rax,%rsi), %r8b
cmpb $0x2f, %r8b
jne 0x29361
movb $0x2f, %r8b
cmpq (%rdi), %rdx
je 0x29361
cmpb $0x2f, -0x1(%rdx)
je 0x29367
movb %r8b, (%rdx)
incq %rdx
incq %rsi
cmpq %rsi, %rcx
jne 0x29... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x23333(%rip), %r14 # 0x4c6d8
movq %r14, (%rdi)
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x60(%rbp), %rdi
movq %rax, %rs... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-matchers.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(char const*) | Matcher<const std::string&>::Matcher(const char* s) {
*this = Eq(std::string(s));
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x231c5(%rip), %r14 # 0x4c6d8
movq %r14, (%rdi)
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x2d590
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-matchers.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x23093(%rip), %r14 # 0x4c708
movq %r14, (%rdi)
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x60(%rbp), %rdi
movq %rax, %rs... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(char const*) | Matcher<internal::StringView>::Matcher(const char* s) {
*this = Eq(std::string(s));
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x22879(%rip), %r14 # 0x4c768
movq %r14, (%rdi)
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x2d590
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(std::basic_string_view<char, std::char_traits<char>>) | Matcher<internal::StringView>::Matcher(internal::StringView s) {
*this = Eq(std::string(s));
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x22717(%rip), %r14 # 0x4c768
movq %r14, (%rdi)
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
leaq (%rsi,%rdx), %rax
leaq -0x60(%rbp), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x3470e
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-matchers.cc |
testing::internal::RE::~RE() | RE::~RE() {
if (is_valid_) {
// regfree'ing an invalid regex might crash because the content
// of the regex is undefined. Since the regex's are essentially
// the same, one cannot be valid (or invalid) without the other
// being so too.
regfree(&partial_regex_);
regfree(&full_regex_);
}
f... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x2a1bd
leaq 0x50(%rbx), %rdi
callq 0x8500
leaq 0x10(%rbx), %rdi
callq 0x8500
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x86c0
movq %rax, %rdi
callq 0x2d7d8
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc |
testing::internal::RE::Init(char const*) | void RE::Init(const char* regex) {
pattern_ = posix::StrDup(regex);
// Reserves enough bytes to hold the regular expression used for a
// full match.
const size_t full_regex_len = strlen(regex) + 10;
char* const full_pattern = new char[full_regex_len];
snprintf(full_pattern, full_regex_len, "^(%s)$", rege... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8a90
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x8230
leaq 0xa(%rax), %r15
movq %r15, %rdi
callq 0x8040
movq %rax, %r14
leaq 0x10e1b(%rip), %rdx # 0x3b0a3
movq %ra... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc |
testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int) | GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
: severity_(severity) {
const char* const marker =
severity == GTEST_INFO ? "[ INFO ]" :
severity == GTEST_WARNING ? "[WARNING]" :
severity == GTEST_ERROR ? "[ ERROR ]" : "[ FATAL ]";
GetStream() << ::std::endl << ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, (%rdi)
cmpl $0x2, %esi
leaq 0x10d29(%rip), %rax # 0x3b1a4
leaq 0x10d2c(%rip), %rcx # 0x3b1ae
cmoveq %rax, %rcx
cmpl $0x1, %esi
leaq 0x10d0a(%rip), %rax # 0x3b19a
cmovneq %rcx, ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc |
testing::internal::GTestLog::~GTestLog() | GTestLog::~GTestLog() {
GetStream() << ::std::endl;
if (severity_ == GTEST_FATAL) {
fflush(stderr);
posix::Abort();
}
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x22a38(%rip), %rdi # 0x4cfe8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x84c0
movsbl %al, %esi
movq 0x22a1d(%rip), %rdi # 0x4cfe8
callq 0x8050
movq %rax, %rdi
callq 0x8350
cmpl $0x3, (%rbx)
je 0x2a5e4
addq $0x8, %rsp
pop... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc |
testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**) | static void CaptureStream(int fd, const char* stream_name,
CapturedStream** stream) {
if (*stream != nullptr) {
GTEST_LOG_(FATAL) << "Only one " << stream_name
<< " capturer can exist at a time.";
}
*stream = new CapturedStream(fd);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %edi, %r14d
cmpq $0x0, (%rdx)
je 0x2a6cc
movq %rsi, %r15
leaq 0x10ab0(%rip), %rdx # 0x3b0f3
leaq -0x24(%rbp), %rdi
movl $0x3, %esi
movl $0x4b0, %ecx # imm = 0x4B0
callq 0x2a45a
movq 0x2298b(%rip),... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc |
testing::internal::ReadEntireFile[abi:cxx11](_IO_FILE*) | std::string ReadEntireFile(FILE* file) {
const size_t file_size = GetFileSize(file);
char* const buffer = new char[file_size];
size_t bytes_last_read = 0; // # of bytes read in the last fread()
size_t bytes_read = 0; // # of bytes read so far
fseek(file, 0, SEEK_SET);
// Keeps reading the file unt... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x85d0
movq %r14, %rdi
callq 0x8030
movq %rax, %r12
movq %rax, %rdi
callq 0x8040
movq %rax, %r15
movq %r14, %rdi
xorl %esi,... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0xf840
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x1068c(%rip), %rsi # 0x3b000
movl $0x6, %r13d
movl $0x6, %edx
movq %r12, %rdi
callq 0x8... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc |
testing::internal::PrintBytesInObjectTo(unsigned char const*, unsigned long, std::ostream*) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
ostream* os) {
PrintBytesInObjectToImpl(obj_bytes, count, os);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x8340
leaq 0x11361(%rip), %rsi # 0x3be31
movl $0xe, %edx
movq %rax, %rdi
callq 0x8620
cmpq $0x83, %r14
ja 0x2aaed
movq %r15, %rdi
xorl %esi, %esi
jmp 0x2ab21
movl $0x40, %edx... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(char32_t, std::ostream*) | void PrintTo(char32_t c, ::std::ostream* os) {
*os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4)
<< static_cast<uint32_t>(c);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movq (%rsi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rsi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rsi,%rax)
leaq 0x106e9(%rip), %rsi # 0x3b27d
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8620
movq... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(char16_t const*, std::ostream*) | void PrintTo(const char16_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x2ade3
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x83e0
leaq 0x113a2(%rip), %rsi # 0x3c155
movl $0xd, %edx
movq %rax, %rdi
callq 0x8620
movq $-0x1, %rsi
cmpw $0x0, 0x2(%r14,%rsi,2)
leaq 0x1(%rsi), %rsi
jne 0x2adc7
movq... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(char32_t const*, std::ostream*) | void PrintTo(const char32_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x2ae4e
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x83e0
leaq 0x11336(%rip), %rsi # 0x3c155
movl $0xd, %edx
movq %rax, %rdi
callq 0x8620
movq $-0x1, %rsi
cmpl $0x0, 0x4(%r14,%rsi,4)
leaq 0x1(%rsi), %rsi
jne 0x2ae33
movq... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(wchar_t const*, std::ostream*) | void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x2aeb1
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x83e0
leaq 0x112cb(%rip), %rsi # 0x3c155
movl $0xd, %edx
movq %rax, %rdi
callq 0x8620
movq %r14, %rdi
callq 0x8430
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc |
testing::internal::PrintStringTo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::ostream*) | void PrintStringTo(const ::std::string& s, ostream* os) {
if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) {
if (GTEST_FLAG(print_utf8)) {
ConditionalPrintAsText(s.data(), s.size(), os);
}
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x2b116
testl %eax, %eax
je 0x2b0cd
cmpb $0x1, 0x22c44(%rip) # 0x4db42
jne 0x2b0cd
movq %rbx, -0x30(%rbp)
movq (%r15), %rbx
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc |
testing::internal::CharFormat testing::internal::PrintCharsAsStringTo<char16_t>(char16_t const*, unsigned long, std::ostream*) | static CharFormat PrintCharsAsStringTo(
const CharType* begin, size_t len, ostream* os) {
const char* const quote_prefix = GetCharWidthPrefix(*begin);
*os << quote_prefix << "\"";
bool is_previous_hex = false;
CharFormat print_format = kAsIs;
for (size_t index = 0; index < len; ++index) {
const CharTy... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10f3e(%rip), %rsi # 0x3c169
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8620
leaq 0xf660(%rip), %rsi # 0x3a89f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8620
testq %r14,... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc |
testing::internal::HasNewFatalFailureHelper::~HasNewFatalFailureHelper() | HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(
original_reporter_);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x208e0(%rip), %rax # 0x4c040
movq %rax, (%rdi)
callq 0xb8c6
movq 0x10(%rbx), %rbx
movl $0x90, %edi
addq 0x22488(%rip), %rdi # 0x4dc00
callq 0x351a0
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x2d7d8
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-test-part.cc |
testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames(char const*, char const*, int, char const*) | const char* TypedTestSuitePState::VerifyRegisteredTestNames(
const char* test_suite_name, const char* file, int line,
const char* registered_tests) {
RegisterTypeParameterizedTestSuite(test_suite_name, CodeLocation(file, line));
typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
registered_ =... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r8, %r15
movl %ecx, %r12d
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, -0x58(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rdx
movq %r13, %rsi
callq 0x2d590
leaq -0xe8(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x90(%... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-typed-test.cc |
testing::internal::ExecDeathTestChildMain(void*) | static int ExecDeathTestChildMain(void* child_arg) {
ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
// We need to execute the test program in the same environment where
// it was originally invoked. Therefore we change to the... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %r14
movl 0x8(%r14), %edi
callq 0x8b40
cmpl $-0x1, %eax
jne 0x2be2a
callq 0x8070
cmpl $0x4, (%rax)
je 0x2bdb0
leaq -0xd8(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xefee(%rip), %rsi ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc |
testing::TestInfo* testing::RegisterTest<testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::InsertSynthetic... | explicit FactoryImpl(Factory f) : factory_(std::move(f)) {} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1fd40(%rip), %rax # 0x4c580
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x2c85b
movq (%rax), %rsi
incq %rsi
callq 0x8520
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x2c879
movq (%rbx), %rsi
inc... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::TestInfo* testing::RegisterTest<testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::InsertSynthetic... | Test* CreateTest() override { return factory_(); } | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1fcf0(%rip), %rax # 0x4c580
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x2c8ab
movq (%rax), %rsi
incq %rsi
callq 0x8520
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x2c8c3
movq (%rax), %rs... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::TestInfo* testing::RegisterTest<testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::InsertSynthetic... | Test* CreateTest() override { return factory_(); } | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x60, %edi
callq 0x84f0
movq %rax, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0xa940
addq $0x28, %r14
leaq -0x38(%rbp), %rdx
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::internal::(anonymous namespace)::FailureTest::FailureTest(testing::internal::CodeLocation const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) | explicit FailureTest(const CodeLocation& loc, std::string error_message,
bool as_error)
: loc_(loc),
error_message_(std::move(error_message)),
as_error_(as_error) {} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x13280
leaq 0x1fc29(%rip), %rax # 0x4c5c0
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0xa... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::FailureTest::~FailureTest() | explicit FailureTest(const CodeLocation& loc, std::string error_message,
bool as_error)
: loc_(loc),
error_message_(std::move(error_message)),
as_error_(as_error) {} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1fb24(%rip), %rax # 0x4c5c0
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
leaq 0x48(%rbx), %rax
cmpq %rax, %rdi
je 0x2cab7
movq (%rax), %rsi
incq %rsi
callq 0x8520
movq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x2cacf
movq (%rax), %r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::FailureTest::TestBody() | void TestBody() override {
if (as_error_) {
AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(),
loc_.line, "") = Message() << error_message_;
} else {
std::cout << error_message_ << std::endl;
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
cmpb $0x1, 0x58(%rdi)
jne 0x2cb74
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0xf840
movq (%rbx), %rbx
leaq 0x10(%rbx), %rdi
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
callq 0x8620
movq 0x10(%r14), %rdx
movl 0x30(%r14), %ecx
leaq 0xd978... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestInfo* testing::RegisterTest<testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0)::FactoryImpl::~FactoryImpl() | Test* CreateTest() override { return factory_(); } | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1fa24(%rip), %rax # 0x4c618
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x2cc0f
movq (%rax), %rsi
incq %rsi
callq 0x8520
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x2cc27
movq (%rax), %r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::TestInfo* testing::RegisterTest<testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0)::FactoryImpl::~FactoryImpl() | Test* CreateTest() override { return factory_(); } | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1f9bc(%rip), %rax # 0x4c618
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x2cc77
movq (%rax), %rsi
incq %rsi
callq 0x8520
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x2cc8f
movq (%rax), %r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::TestInfo* testing::RegisterTest<testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0)::FactoryImpl::CreateTest() | Test* CreateTest() override { return factory_(); } | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x60, %edi
callq 0x84f0
movq %rax, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0xa940
addq $0x48, %r14
leaq -0x38(%rbp), %rdx
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const*, char const*) | static std::string FormatCxxExceptionMessage(const char* description,
const char* location) {
Message message;
if (description != nullptr) {
message << "C++ exception with description \"" << description << "\"";
} else {
message << "Unknown C++ exception";
}
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0xf840
movq (%r15), %r15
addq $0x10, %r15
testq %r12, %r12
je 0x2cdc3
leaq 0xf141(%rip), %rsi # 0x3bed3
movl $0x20, %edx
movq %r15, %r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::ParseGoogleTestFlag(char const*) | static bool ParseGoogleTestFlag(const char* const arg) {
return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
>EST_FLAG(also_run_disabled_tests)) ||
ParseBoolFlag(arg, kBreakOnFailureFlag,
>EST_FLAG(break_on_failure)) ||
ParseBoolFlag(arg, kCatchExce... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb85d(%rip), %rsi # 0x386e0
leaq 0x20c49(%rip), %rdx # 0x4dad3
callq 0x2d40f
testb %al, %al
jne 0x2d09f
leaq 0xb862(%rip), %rsi # 0x38700
leaq 0x20c2f(%rip), %rdx # 0x4dad4
movq %rbx, %rdi
callq 0x2d40f
testb %al, %al
jne 0x2d09f
l... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::ParseBoolFlag(char const*, char const*, bool*) | static bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag, true);
// Aborts if the parsing failed.
if (value_str == nullptr) return false;
// Converts the string value to a bool.
*value = !(... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl $0x1, %edx
callq 0x22461
testq %rax, %rax
je 0x2d43e
movzbl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x30, %edx
je 0x2d43c
cmpl $0x66, %edx
je 0x2d43c
cmpb $0x46, %dl
setne %cl
movb %cl, (%rbx)
testq %rax, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::PrintAsStringLiteralTo(char32_t, std::ostream*) | static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
switch (c) {
case L'\'':
*os << "'";
return kAsIs;
case L'"':
*os << "\\\"";
return kSpecialEscape;
default:
return PrintAsCharLiteralTo(c, os);
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0x21, %edi
jg 0x2d486
cmpl $0xd, %r14d
ja 0x2d50d
movl %r14d, %eax
leaq 0xb214(%rip), %rcx # 0x38688
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xca3b(%rip), %rsi # 0x39ebf
jmp 0x2d4f0... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<double>(double const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xf840
movq (%r15), %rdi
addq $0x10, %rdi
movsd (%r14), %xmm0
callq 0x8970
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0xb0d6
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [15]>(char const (&) [15]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [27]>(char const (&) [27]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [100]>(char const (&) [100]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [106]>(char const (&) [106]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
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.