name string | code string | asm string | file string |
|---|---|---|---|
coda_get_uint64set(char const*, std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>>&) | void coda_get_uint64set(const char* str, std::set<uint64_t>& result)
{
const char* i = str;
while (i)
{
uint64_t temp;
sscanf(i, "%" PRIu64, &temp);
result.insert(temp);
i = strchr(i, ',');
if (i)
{
++i;
}
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xfcbc
movq 0x20(%rsp), %rdi
leaq 0x34c9(%rip), %rsi # 0x13135
leaq 0x18(%rsp), %rdx
movb $0x0, %al
callq 0xc200
movq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x10380
movq %rax, 0x8... | /bachan[P]coda/coda/string.cpp |
coda_split_string[abi:cxx11](char const*, char const*, bool) | std::vector<std::string> coda_split_string(const char *src, const char *delimiters, bool ignore_empty)
{
std::vector<std::string> result;
const char *prev_ptr = src;
const char *p = src;
for (; *p; ++p)
{
if (NULL != strchr(delimiters, *p))
{
if (prev_ptr < p || !ignore_empty)
{
result.push_back(std... | subq $0xd8, %rsp
movq %rdi, 0x38(%rsp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, 0x40(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
andb $0x1, %al
movb %al, 0xbf(%rsp)
movb $0x0, 0xbe(%rsp)
callq 0x103e0
movq 0xc8(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0xa8(%rsp)
mov... | /bachan[P]coda/coda/string.cpp |
coda_split_string[abi:cxx11](char const*, unsigned long, char const*, bool) | std::vector<std::string> coda_split_string(const char *src, size_t size, const char *delimiters, bool ignore_empty)
{
std::vector<std::string> result;
const char *prev_ptr = src;
const char *p = src;
const char *e = src + size;
for (; p < e; ++p)
{
if (NULL != strchr(delimiters, *p))
{
if (prev_ptr < p ||... | subq $0xe8, %rsp
movq %rdi, 0x38(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x40(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
andb $0x1, %al
movb %al, 0xc7(%rsp)
movb $0x0, 0xc6(%rsp)
callq 0x103e0
movq 0xd8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xd8(%rsp), %rax
movq... | /bachan[P]coda/coda/string.cpp |
rcg::Buffer::getWidth(unsigned int) const | size_t Buffer::getWidth(uint32_t part) const
{
if (multipart)
{
return getBufferPartValue<size_t>(gentl, parent->getHandle(), buffer, part,
GenTL::BUFFER_PART_INFO_WIDTH);
}
else
{
if (payload_type == PAYLOAD_TYPE_CHUNK_DATA && nodemap)
{
try
{
... | pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x15962
movl %esi, %ebp
movq (%rbx), %rdi
callq 0x120fe
movq 0x18(%rbx), %rsi
movq $0x0, 0x10(%rsp)
movq $0x8, 0x18(%rsp)
testq %rax, %rax
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x159f9
movq 0x8(%rbx), %r10
leaq 0x18(%rsp), %r... | /roboception[P]rc_genicam_api/rc_genicam_api/buffer.cc |
rcg::Buffer::getXPadding(unsigned int) const | size_t Buffer::getXPadding(uint32_t part) const
{
if (multipart)
{
return getBufferPartValue<size_t>(gentl, parent->getHandle(), buffer, part,
GenTL::BUFFER_PART_INFO_XPADDING);
}
else
{
return getBufferValue<size_t>(gentl, parent->getHandle(), buffer, GenTL::BUFF... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
movb 0x28(%rdi), %bpl
movq (%rdi), %rdi
callq 0x120fe
movq 0x18(%r14), %rsi
testq %rax, %rax
setne %dl
testq %rsi, %rsi
setne %cl
andb %dl, %cl
cmpb $0x1, %bpl
jne 0x15db3
movq $0x0, 0x8(%rsp)
movq $0x8, 0x10(%rsp)
testb %cl, %cl
je 0x15d... | /roboception[P]rc_genicam_api/rc_genicam_api/buffer.cc |
rcg::Buffer::getPayloadType() const | size_t Buffer::getPayloadType() const
{
return getBufferValue<size_t>(gentl, parent->getHandle(), buffer,
GenTL::BUFFER_INFO_PAYLOADTYPE);
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x120fe
movq 0x18(%rbx), %rsi
movq $0x0, 0x8(%rsp)
movq $0x8, 0x10(%rsp)
testq %rax, %rax
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x16035
movq 0x8(%rbx), %r10
leaq 0x1c(%rsp), %rcx
leaq 0x8(%rsp), %r8
leaq 0x10(%rsp), %r9
movq %rax, %rdi
mo... | /roboception[P]rc_genicam_api/rc_genicam_api/buffer.cc |
rcg::Buffer::getPixelFormat(unsigned int) const | uint64_t Buffer::getPixelFormat(uint32_t part) const
{
if (multipart)
{
return getBufferPartValue<uint64_t>(gentl, parent->getHandle(), buffer, part,
GenTL::BUFFER_PART_INFO_DATA_FORMAT);
}
else
{
if (payload_type == PAYLOAD_TYPE_CHUNK_DATA && nodemap)
{
... | pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x160b0
movl %esi, %ebp
movq (%rbx), %rdi
callq 0x120fe
movq 0x18(%rbx), %rsi
movq $0x0, 0x10(%rsp)
movq $0x8, 0x18(%rsp)
testq %rax, %rax
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x16147
movq 0x8(%rbx), %r10
leaq 0x18(%rsp), %r... | /roboception[P]rc_genicam_api/rc_genicam_api/buffer.cc |
rcg::Buffer::getTimestampNS() const | uint64_t Buffer::getTimestampNS() const
{
uint64_t ret=getBufferValue<uint64_t>(gentl, parent->getHandle(), buffer,
GenTL::BUFFER_INFO_TIMESTAMP_NS);
// if timestamp in nano seconds is not available, then compute it from
// timestamp and device frequency
if (ret == 0)
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x120fe
movq 0x18(%rbx), %rsi
movq $0x0, 0x8(%rsp)
movq $0x8, 0x18(%rsp)
testq %rax, %rax
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x167ab
movq 0x8(%rbx), %r10
leaq 0x24(%rsp), %rcx
leaq 0x8(%rsp), %r8
leaq 0x18(%rsp), %r9
movq %r... | /roboception[P]rc_genicam_api/rc_genicam_api/buffer.cc |
rcg::setBoolean(std::shared_ptr<GenApi_3_4::CNodeMapRef> const&, char const*, bool, bool) | bool setBoolean(const std::shared_ptr<GenApi::CNodeMapRef> &nodemap, const char *name,
bool value, bool exception)
{
bool ret=false;
try
{
GenApi::INode *node=nodemap->_GetNode(name);
if (node != 0)
{
if (GenApi::IsWritable(node))
{
GenApi::IBoolean *val=dynamic_c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq (%rdi), %r15
leaq 0x28(%rsp), %rdi
callq 0x7900
movq (%r15), %rax
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0x7550
testq %r15,... | /roboception[P]rc_genicam_api/rc_genicam_api/config.cc |
rcg::setEnum(std::shared_ptr<GenApi_3_4::CNodeMapRef> const&, char const*, char const*, bool) | bool setEnum(const std::shared_ptr<GenApi::CNodeMapRef> &nodemap, const char *name,
const char *value, bool exception)
{
bool ret=false;
try
{
GenApi::INode *node=nodemap->_GetNode(name);
if (node != 0)
{
if (GenApi::IsWritable(node))
{
GenApi::IEnumeration *val=dyna... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %ecx, %ebx
movq %rdx, %rbp
movq %rsi, %r13
movq (%rdi), %r14
leaq 0x28(%rsp), %rdi
callq 0x7900
movq (%r14), %rax
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x7550
testq %r14,... | /roboception[P]rc_genicam_api/rc_genicam_api/config.cc |
rcg::setString(std::shared_ptr<GenApi_3_4::CNodeMapRef> const&, char const*, char const*, bool) | bool setString(const std::shared_ptr<GenApi::CNodeMapRef> &nodemap, const char *name,
const char *value, bool exception)
{
bool ret=false;
try
{
GenApi::INode *node=nodemap->_GetNode(name);
if (node != 0)
{
if (GenApi::IsWritable(node))
{
switch (node->GetPrincipal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movl %ecx, 0x2c(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq (%rdi), %rbx
leaq 0x80(%rsp), %rdi
callq 0x7900
movq (%rbx), %rax
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq *0x38(%rax)
movq %rax, %rbx
leaq 0x80(%rsp... | /roboception[P]rc_genicam_api/rc_genicam_api/config.cc |
leveldb::log::LogTest::Write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Write(const std::string& msg) {
ASSERT_TRUE(!reading_) << "Write() after starting to read";
writer_->AddRecord(Slice(msg));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movb 0x88(%rdi), %al
movl %eax, %ecx
xorb $0x1, %cl
leaq 0x20(%rsp), %rbx
movb %cl, -0x8(%rbx)
andq $0x0, (%rbx)
testb %al, %al
je 0x10347
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x16112
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x20456(%rip), %rsi # 0x... | /walterzhaoJR[P]leveldb/db/log_test.cc |
leveldb::log::LogTest_MarginalTrailer_Test::~LogTest_MarginalTrailer_Test() | TEST_F(LogTest, MarginalTrailer) {
// Make a trailer that is exactly the same length as an empty record.
const int n = kBlockSize - 2 * kHeaderSize;
Write(BigString("foo", n));
ASSERT_EQ(kBlockSize - kHeaderSize, WrittenBytes());
Write("");
Write("bar");
ASSERT_EQ(BigString("foo", n), Read());
ASSERT_EQ... | pushq %rbx
movq %rdi, %rbx
callq 0x10d14
movq %rbx, %rdi
popq %rbx
jmp 0x9470
| /walterzhaoJR[P]leveldb/db/log_test.cc |
leveldb::log::LogTest_RandomRead_Test::~LogTest_RandomRead_Test() | TEST_F(LogTest, RandomRead) {
const int N = 500;
Random write_rnd(301);
for (int i = 0; i < N; i++) {
Write(RandomSkewedString(i, &write_rnd));
}
Random read_rnd(301);
for (int i = 0; i < N; i++) {
ASSERT_EQ(RandomSkewedString(i, &read_rnd), Read());
}
ASSERT_EQ("EOF", Read());
} | pushq %rbx
movq %rdi, %rbx
callq 0x10d14
movq %rbx, %rdi
popq %rbx
jmp 0x9470
| /walterzhaoJR[P]leveldb/db/log_test.cc |
leveldb::log::LogTest_TruncatedTrailingRecordIsIgnored_Test::~LogTest_TruncatedTrailingRecordIsIgnored_Test() | TEST_F(LogTest, TruncatedTrailingRecordIsIgnored) {
Write("foo");
ShrinkSize(4); // Drop all payload as well as a header byte
ASSERT_EQ("EOF", Read());
// Truncated last record is ignored, not treated as an error.
ASSERT_EQ(0, DroppedBytes());
ASSERT_EQ("", ReportMessage());
} | pushq %rbx
movq %rdi, %rbx
callq 0x10d14
movq %rbx, %rdi
popq %rbx
jmp 0x9470
| /walterzhaoJR[P]leveldb/db/log_test.cc |
leveldb::log::LogTest_SkipIntoMultiRecord_Test::~LogTest_SkipIntoMultiRecord_Test() | TEST_F(LogTest, SkipIntoMultiRecord) {
// Consider a fragmented record:
// first(R1), middle(R1), last(R1), first(R2)
// If initial_offset points to a record after first(R1) but before first(R2)
// incomplete fragment errors are not actual errors, and must be suppressed
// until a new first or full record ... | pushq %rbx
movq %rdi, %rbx
callq 0x10d14
movq %rbx, %rdi
popq %rbx
jmp 0x9470
| /walterzhaoJR[P]leveldb/db/log_test.cc |
leveldb::Slice::ToString[abi:cxx11]() const | std::string ToString() const { return std::string(data_, size_); } | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x10(%rdi), %rcx
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rcx, (%rdi)
movq %rax, %rsi
callq 0x111e8
movq %rbx, %rax
popq %rbx
retq
| /walterzhaoJR[P]leveldb/include/leveldb/slice.h |
leveldb::log::LogTest_ReadWrite_Test::LogTest_ReadWrite_Test() | TEST_F(LogTest, ReadWrite) {
Write("foo");
Write("bar");
Write("");
Write("xxxx");
ASSERT_EQ("foo", Read());
ASSERT_EQ("bar", Read());
ASSERT_EQ("", Read());
ASSERT_EQ("xxxx", Read());
ASSERT_EQ("EOF", Read());
ASSERT_EQ("EOF", Read()); // Make sure reads at eof work
} | pushq %rbx
movq %rdi, %rbx
callq 0x10dd2
leaq 0x38d7c(%rip), %rax # 0x4a060
movq %rax, (%rbx)
popq %rbx
retq
nop
| /walterzhaoJR[P]leveldb/db/log_test.cc |
leveldb::log::LogTest_Fragmentation_Test::LogTest_Fragmentation_Test() | TEST_F(LogTest, Fragmentation) {
Write("small");
Write(BigString("medium", 50000));
Write(BigString("large", 100000));
ASSERT_EQ("small", Read());
ASSERT_EQ(BigString("medium", 50000), Read());
ASSERT_EQ(BigString("large", 100000), Read());
ASSERT_EQ("EOF", Read());
} | pushq %rbx
movq %rdi, %rbx
callq 0x10dd2
leaq 0x38d7e(%rip), %rax # 0x4a0e0
movq %rax, (%rbx)
popq %rbx
retq
nop
| /walterzhaoJR[P]leveldb/db/log_test.cc |
leveldb::log::LogTest_ShortTrailer_Test::LogTest_ShortTrailer_Test() | TEST_F(LogTest, ShortTrailer) {
const int n = kBlockSize - 2 * kHeaderSize + 4;
Write(BigString("foo", n));
ASSERT_EQ(kBlockSize - kHeaderSize + 4, WrittenBytes());
Write("");
Write("bar");
ASSERT_EQ(BigString("foo", n), Read());
ASSERT_EQ("", Read());
ASSERT_EQ("bar", Read());
ASSERT_EQ("EOF", Read()... | pushq %rbx
movq %rdi, %rbx
callq 0x10dd2
leaq 0x38d96(%rip), %rax # 0x4a1a0
movq %rax, (%rbx)
popq %rbx
retq
nop
| /walterzhaoJR[P]leveldb/db/log_test.cc |
leveldb::log::LogTest_RandomRead_Test::LogTest_RandomRead_Test() | TEST_F(LogTest, RandomRead) {
const int N = 500;
Random write_rnd(301);
for (int i = 0; i < N; i++) {
Write(RandomSkewedString(i, &write_rnd));
}
Random read_rnd(301);
for (int i = 0; i < N; i++) {
ASSERT_EQ(RandomSkewedString(i, &read_rnd), Read());
}
ASSERT_EQ("EOF", Read());
} | pushq %rbx
movq %rdi, %rbx
callq 0x10dd2
leaq 0x38dae(%rip), %rax # 0x4a260
movq %rax, (%rbx)
popq %rbx
retq
nop
| /walterzhaoJR[P]leveldb/db/log_test.cc |
leveldb::log::LogTest_TruncatedTrailingRecordIsIgnored_Test::LogTest_TruncatedTrailingRecordIsIgnored_Test() | TEST_F(LogTest, TruncatedTrailingRecordIsIgnored) {
Write("foo");
ShrinkSize(4); // Drop all payload as well as a header byte
ASSERT_EQ("EOF", Read());
// Truncated last record is ignored, not treated as an error.
ASSERT_EQ(0, DroppedBytes());
ASSERT_EQ("", ReportMessage());
} | pushq %rbx
movq %rdi, %rbx
callq 0x10dd2
leaq 0x38d88(%rip), %rax # 0x4a320
movq %rax, (%rbx)
popq %rbx
retq
nop
| /walterzhaoJR[P]leveldb/db/log_test.cc |
leveldb::log::LogTest_BadLength_Test::LogTest_BadLength_Test() | TEST_F(LogTest, BadLength) {
const int kPayloadSize = kBlockSize - kHeaderSize;
Write(BigString("bar", kPayloadSize));
Write("foo");
// Least significant size byte is stored in header[4].
IncrementByte(4, 1);
ASSERT_EQ("foo", Read());
ASSERT_EQ(kBlockSize, DroppedBytes());
ASSERT_EQ("OK", MatchError("ba... | pushq %rbx
movq %rdi, %rbx
callq 0x10dd2
leaq 0x38d90(%rip), %rax # 0x4a360
movq %rax, (%rbx)
popq %rbx
retq
nop
| /walterzhaoJR[P]leveldb/db/log_test.cc |
leveldb::log::Reader::SkipToInitialBlock() | bool Reader::SkipToInitialBlock() {
const size_t offset_in_block = initial_offset_ % kBlockSize;
uint64_t block_start_location = initial_offset_ - offset_in_block;
// Don't search a block if we'd be in the trailer
if (offset_in_block > kBlockSize - 6) {
block_start_location += kBlockSize;
}
end_of_buf... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x48(%rdi), %rax
movl %eax, %ecx
andl $0x7fff, %ecx # imm = 0x7FFF
andq $-0x8000, %rax # imm = 0x8000
leaq 0x8000(%rax), %r15
cmpl $0x7ffb, %ecx # imm = 0x7FFB
cmovbq %rax, %r15
movq %r15, 0x40(%rdi)
movb $0x1, %bl
testq %r15, %r15... | /walterzhaoJR[P]leveldb/db/log_reader.cc |
leveldb::crc32c::Extend(unsigned int, char const*, unsigned long) | uint32_t Extend(uint32_t crc, const char* data, size_t n) {
static bool accelerate = CanAccelerateCRC32C();
if (accelerate) {
return port::AcceleratedCRC32C(crc, data, n);
}
const uint8_t* p = reinterpret_cast<const uint8_t*>(data);
const uint8_t* e = p + n;
uint32_t l = crc ^ kCRC32Xor;
// Process on... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
movb 0x3952e(%rip), %al # 0x4c740
testb %al, %al
je 0x134c6
addq %r14, %rbx
notl %r15d
leaq 0x3(%r14), %rax
andq $-0x4, %rax
cmpq %rax, %rbx
jae 0x13232
movq %r14, %rax
jmp 0x13262
movq %ra... | /walterzhaoJR[P]leveldb/util/crc32c.cc |
leveldb::ReadFileToString(leveldb::Env*, 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>>*) | Status ReadFileToString(Env* env, const std::string& fname, std::string* data) {
data->clear();
SequentialFile* file;
Status s = env->NewSequentialFile(fname, &file);
if (!s.ok()) {
return s;
}
static const int kBufferSize = 8192;
char* space = new char[kBufferSize];
while (true) {
Slice fragmen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
andq $0x0, 0x8(%rcx)
movq %rdi, %rbx
movq (%rcx), %rax
movb $0x0, (%rax)
movq (%rsi), %rax
leaq 0x20(%rsp), %rcx
callq *0x10(%rax)
cmpq $0x0, (%rbx)
jne 0x13817
movl $0x2000, %edi # imm = 0x2000
callq 0x9040
mov... | /walterzhaoJR[P]leveldb/util/env.cc |
leveldb::Status::Status(leveldb::Status::Code, leveldb::Slice const&, leveldb::Slice const&) | Status::Status(Code code, const Slice& msg, const Slice& msg2) {
assert(code != kOk);
const uint32_t len1 = static_cast<uint32_t>(msg.size());
const uint32_t len2 = static_cast<uint32_t>(msg2.size());
const uint32_t size = len1 + (len2 ? (2 + len2) : 0);
char* result = new char[size + 5];
std::memcpy(result... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
testl %esi, %esi
je 0x13a88
movq %rdx, %r12
movl %esi, %ebp
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rbx
leal 0x2(%rbx), %eax
testl %ebx, %ebx
cmovel %ebx, %eax
movq 0x8(%rdx), %r13
leal (%rax,%r13), %edi
addl $0x5, %e... | /walterzhaoJR[P]leveldb/util/status.cc |
testing::internal::BoolFromGTestEnv(char const*, bool) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
#if defined(GTEST_GET_BOOL_FROM_ENV_)
return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
#else
const std::string env_var = FlagToEnvVar(flag);
const char* const string_value = posix::GetEnv(env_var.c_str());
return string_value == nullptr ? defaul... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x25a3e
movq (%r14), %rdi
callq 0x9620
testq %rax, %rax
je 0x13b6c
movb $0x1, %bl
cmpb $0x30, (%rax)
jne 0x13b6c
cmpb $0x0, 0x1(%rax)
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x9ac8
movl %ebx, %eax
addq $0x28, ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-port.cc |
testing::internal::OutputFlagAlsoCheckEnvVar[abi:cxx11]() | std::string OutputFlagAlsoCheckEnvVar(){
std::string default_value_for_output_flag = "";
const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
if (nullptr != xml_output_file_env) {
default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
}
return default_value_for_output_fl... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x1ffbc(%rip), %rsi # 0x33b8e
leaq 0x28(%rsp), %rdx
callq 0x91d0
leaq 0x20ce4(%rip), %rdi # 0x348c7
callq 0x9620
testq %rax, %rax
je 0x13c3a
movq %rax, %r14
leaq 0x20ce0(%rip), %rsi # 0x348d7
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x91d0
l... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-port.cc |
testing::internal::Random::Generate(unsigned int) | uint32_t Random::Generate(uint32_t range) {
// These constants are the same as are used in glibc's rand(3).
// Use wider types than necessary to prevent unsigned overflow diagnostics.
state_ = static_cast<uint32_t>(1103515245ULL*state_ + 12345U) % kMaxRange;
GTEST_CHECK_(range > 0)
<< "Cannot generate a ... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
imull $0x41c64e6d, (%rdi), %eax # imm = 0x41C64E6D
addl $0x3039, %eax # imm = 0x3039
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movl %eax, (%rdi)
testl %esi, %esi
je 0x13e5f
cmpl $0x80000001, %ebx # imm = 0x80000001
jb 0x13ea4
leaq 0x... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::AssertHelper::operator=(testing::Message const&) const | void AssertHelper::operator=(const Message& message) const {
UnitTest::GetInstance()->
AddTestPartResult(data_->type, data_->file, data_->line,
AppendUserMessage(data_->message, message),
UnitTest::GetInstance()->impl()
->CurrentOsStackTraceExceptT... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x13ffa
movq (%rbx), %rsi
movl (%rsi), %ebx
movq 0x8(%rsi), %r14
movl 0x10(%rsi), %ebp
addq $0x18, %rsi
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x1432b
callq 0x13ffa
movq 0x388ec(%rip), %rsi # 0x4c878
leaq 0x8(%rs... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&) | std::string AppendUserMessage(const std::string& gtest_msg,
const Message& user_msg) {
// Appends the user message if it's non-empty.
const std::string user_msg_string = user_msg.GetString();
if (user_msg_string.empty()) {
return gtest_msg;
}
return gtest_msg + "\n" + user_m... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x162d2
cmpq $0x0, 0x8(%r15)
je 0x1437d
leaq 0x1f835(%rip), %rdx # 0x33b8d
movq %rsp, %rdi
movq %r14, %rsi
callq 0x27627
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::RegisterTypeParameterizedTestSuite(char const*, testing::internal::CodeLocation) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
CodeLocation code_location) {
GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(
test_suite_name, code_location);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x27514
leaq 0x100(%rax), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x274f6
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x14802
movq %rsp, %rdi
callq 0x9ac8
addq $0x28, %rsp
popq %rbx
popq %r12
... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::GetCurrentExecutableName() | FilePath GetCurrentExecutableName() {
FilePath result;
#if GTEST_OS_WINDOWS || GTEST_OS_OS2
result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
#else
result.Set(FilePath(GetArgvs()[0]));
#endif // GTEST_OS_WINDOWS
return result.RemoveDirectoryName();
} | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x275e4
leaq 0x8(%rsp), %rdi
callq 0x14ccc
movq 0x8(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x275f8
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x9290
leaq 0x40(%rsp), %rdi
callq 0x9ac8
leaq 0x8(%rsp), %rdi
callq 0x2756e
leaq 0x20(%rsp), %rsi... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::FilePath::ConcatPaths(testing::internal::FilePath const&, testing::internal::FilePath const&) | FilePath FilePath::ConcatPaths(const FilePath& directory,
const FilePath& relative_path) {
if (directory.IsEmpty())
return relative_path;
const FilePath dir(directory.RemoveTrailingPathSeparator());
return FilePath(dir.string() + kPathSeparator + relative_path.string());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x15472
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x24fa8
movq %rsp, %rdi
pushq $0x2f
popq %rdx
movq %r15, %rsi
callq 0x2a1c8
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x27460
leaq 0x20(%rsp), %... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-filepath.cc |
testing::internal::UnitTestOptions::MatchesFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) | bool UnitTestOptions::MatchesFilter(
const std::string& name, const char* filter) {
const char *cur_pattern = filter;
for (;;) {
if (PatternMatchesString(cur_pattern, name.c_str())) {
return true;
}
// Finds the next pattern in the filter.
cur_pattern = strchr(cur_pattern, ':');
// R... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %rbx
pushq $0x3a
popq %rbp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15562
movl %eax, %r15d
testb %al, %al
jne 0x15601
movq %r14, %rdi
movl %ebp, %esi
callq 0x91c0
leaq 0x1(%rax), %r14
testq %rax, %rax
jne 0x155dc
movl %r15d, %eax
addq $0... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestOptions::FilterMatchesTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name,
const std::string& test_name) {
const std::string& full_name = test_suite_name + "." + test_name.c_str();
// Split --gtest_filter at '-', if there is one, to separate into
// positive filter and ne... | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x1e8b6(%rip), %rdx # 0x33edf
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x27627
movq (%rbx), %rdx
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
callq 0x27441
leaq 0x10(%rsp), %rdi
callq 0x9ac8
movq 0x37119(%rip), %rbx # 0x4c770
pus... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::Message::operator<<(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&) | Message& Message::operator <<(const ::std::wstring& wstr) {
internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
return *this;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
xorl %r13d, %r13d
movq %rsp, %r14
cmpq %r13, %r12
je 0x162ae
cmpl $0x0, (%r15,%r13,4)
je 0x16295
leaq (%r15,%r13,4), %rsi
movl %r12d, %edx
subl %r13d, %edx
movq %r14, %rdi
callq 0x188ac
movq %r... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::TestResult::RecordProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::TestProperty const&) | void TestResult::RecordProperty(const std::string& xml_element,
const TestProperty& test_property) {
if (!ValidateTestProperty(xml_element, test_property)) {
return;
}
internal::MutexLock lock(&test_properites_mutex_);
const std::vector<TestProperty>::iterator property_with_m... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x18ec2
testb %al, %al
je 0x18e7c
movq %r14, 0x10(%rsp)
movq %r14, %rdi
callq 0x2aa8e
movq 0x50(%r14), %r15
movq 0x58(%r14), %r12
movq (%rbx), %rsi
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rd... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::PrintTestPartResultToString[abi:cxx11](testing::TestPartResult const&) | static std::string PrintTestPartResultToString(
const TestPartResult& test_part_result) {
return (Message()
<< internal::FormatFileLocation(test_part_result.file_name(),
test_part_result.line_number())
<< " " << TestPartResultTypeToString(test_part_res... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x16112
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x198d1
movq 0x8(%r14), %rsi
movl 0x28(%r14), %edx
leaq 0x20(%rsp), %rdi
callq 0x19f81
movq 0x8(%rsp), %r15
addq $0x10, %r15
leaq 0x20(%rsp), %rsi
movq %r15, %rd... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::TestInfo::TestInfo(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&, char const*, char const*, testing::internal::CodeLocation, void const*, testing::internal::TestFactoryBase*) | TestInfo::TestInfo(const std::string& a_test_suite_name,
const std::string& a_name, const char* a_type_param,
const char* a_value_param,
internal::CodeLocation a_code_location,
internal::TypeId fixture_class_id,
internal::Tes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, %rbp
movq %rcx, %r13
movq %rdx, %r14
movq %rdi, %rbx
callq 0x9760
leaq 0x20(%rbx), %rdi
movq %rdi, 0x10(%rsp)
movq %r14, %rsi
callq 0x9760
leaq 0x40(%rbx), %r15
testq %r13, %r13
je 0x19b72
pushq $0x20
popq %rdi
c... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::FormatFileLocation[abi:cxx11](char const*, int) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
const std::string file_name(file == nullptr ? kUnknownFile : file);
if (line < 0) {
return file_name + ":";
}
#ifdef _MSC_VER
return file_name + "(" + StreamableToString(line) + "):";
#else
return file_name + ":" + StreamableToStri... | pushq %rbp
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
testq %rsi, %rsi
leaq 0x18533(%rip), %rax # 0x324d0
cmoveq %rax, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x91d0
testl %ebp, %ebp
js 0x1a021
leaq 0x1a06b(%rip), %rdx # 0x34026
leaq 0x68(%rsp), %rdi
leaq 0x28... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-port.cc |
testing::TestInfo::Skip() | void TestInfo::Skip() {
if (!should_run_) return;
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->set_current_test_info(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
// Notifies the unit test event listeners that a test is about to start.
re... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x1a24c
movq %rdi, %rbx
callq 0x27514
movq %rax, %r14
movq %rbx, 0x170(%rax)
callq 0x13ffa
movq 0x32688(%rip), %rax # 0x4c878
movq 0x1f8(%rax), %r15
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x40(%rax)
movq 0x50(%rbx), %rdx
m... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(testing::UnitTest const&, int) | void PrettyUnitTestResultPrinter::OnTestIterationStart(
const UnitTest& unit_test, int iteration) {
if (GTEST_FLAG(repeat) != 1)
printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
const char* const filter = GTEST_FLAG(filter).c_str();
// Prints the filter if it's not *. This remin... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
cmpl $0x1, 0x31f6c(%rip) # 0x4c7c0
je 0x1a868
incl %edx
leaq 0x191d9(%rip), %rdi # 0x33a38
movl %edx, %esi
xorl %eax, %eax
callq 0x9070
movq 0x31f01(%rip), %r14 # 0x4c770
leaq 0x17b40(%rip), %rsi # 0x323b6
movq %r14, %rdi
callq 0x15fde
te... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::ShouldShard(char const*, char const*, bool) | bool ShouldShard(const char* total_shards_env,
const char* shard_index_env,
bool in_subprocess_for_death_test) {
if (in_subprocess_for_death_test) {
return false;
}
const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
const int32_t shard_index = Int32FromE... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
testl %edx, %edx
jne 0x1ab4f
movq %rsi, %r14
pushq $-0x1
popq %rbp
movl %ebp, %esi
callq 0x1ae4e
movl %eax, %ebx
movq %r14, %rdi
movl %ebp, %esi
callq 0x1ae4e
movl %eax, %ebp
andl %ebx, %eax
cmpl $-0x1, %eax
je 0x1ab4f
cmpl $-0x1, %ebx
setne %al
cmpl $-0x1, %ebp
sete %c... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(testing::TestSuite const&) | void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(GTestColor::kGreen, "[----------] ");
printf("%s from %s", counts.c_str(), test_case.name());
if (test_case.type_para... | pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x15f60
leaq 0x1964a(%rip), %rdx # 0x345d9
leaq 0x18b7a(%rip), %rcx # 0x33b10
movq %rsp, %rdi
movl %eax, %esi
callq 0x1b027
leaq 0x18b5b(%rip), %rsi # 0x33b02
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1a99f
movq (%rsp), %rsi
movq 0x8(%rbx)... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::FormatCountableNoun[abi:cxx11](int, char const*, char const*) | static std::string FormatCountableNoun(int count,
const char * singular_form,
const char * plural_form) {
return internal::StreamableToString(count) + " " +
(count == 1 ? singular_form : plural_form);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x29059
leaq 0x1844b(%rip), %rdx # 0x334a4
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x27441
cmpl $0x1, 0x4... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void PrettyUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
switch (result.type()) {
// If the test part succeeded, we don't need to do anything.
case TestPartResult::kSuccess:
return;
default:
// Print failure message from the assertion
// (e.g. expected this... | cmpl $0x0, (%rsi)
je 0x1b11e
pushq %rax
movq %rsi, %rdi
callq 0x1b11f
movq 0x30e73(%rip), %rax # 0x4bf88
movq (%rax), %rdi
popq %rax
jmp 0x95c0
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&) | void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
if (test_info.result()->Passed()) {
ColoredPrintf(GTestColor::kGreen, "[ OK ] ");
} else if (test_info.result()->Skipped()) {
ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
} else {
ColoredPrintf(GTestColor::kRed, "[ ... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %r14
movq %r14, %rdi
callq 0x28ed4
testb %al, %al
je 0x1b17e
leaq 0x189c4(%rip), %rsi # 0x33b40
jmp 0x1b191
movq %r14, %rdi
callq 0x19268
testb %al, %al
je 0x1b195
leaq 0x189bd(%rip), %rsi # 0x33b4e
pushq $0x2
jmp 0x1b19e
leaq 0x189c0(%rip)... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("%s from %s ran.",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTestSu... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x18111(%rip), %rsi # 0x33adf
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1a99f
movq %rbx, %rdi
callq 0x1af1a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x1aefd
movq (%r14), %r14
movq %rbx, %rdi
callq 0x1af40
leaq 0x2... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream*, testing::UnitTest const&) | void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
const UnitTest& unit_test) {
const std::string kTestsuites = "testsuites";
*stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
*stream << "<" << kTestsuites;
OutputXmlAttribute(stream, ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x17c0a(%rip), %rsi # 0x33e25
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x91d0
leaq 0x17bff(%rip), %rsi # 0x33e30
movq %rbx, %rdi
callq 0x9490
leaq 0x17bce(%rip), %rsi # 0x33e0e
movq %rbx, %rdi
callq 0x9490
leaq 0... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestsList(std::ostream*, std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void XmlUnitTestResultPrinter::PrintXmlTestsList(
std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
const std::string kTestsuites = "testsuites";
*stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
*stream << "<" << kTestsuites;
int total_tests = 0;
for (auto test_suite : test_s... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1773d(%rip), %rsi # 0x33e25
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x91d0
leaq 0x17732(%rip), %rsi # 0x33e30
movq %rbx, %rdi
callq 0x9490
leaq 0x17701(%rip), %rsi # 0x33e0e
movq %rbx, %rdi
callq 0x9490
leaq 0... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::PortableLocaltime(long, tm*) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
#if defined(_MSC_VER)
return localtime_s(out, &seconds) == 0;
#elif defined(__MINGW32__) || defined(__MINGW64__)
// MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
// Windows' localtime(), which has a thread-local tm buffer.
s... | pushq %rax
movq %rsp, %rax
movq %rdi, (%rax)
movq %rax, %rdi
callq 0x9270
testq %rax, %rax
setne %al
popq %rcx
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlAttribute(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::alloc... | void XmlUnitTestResultPrinter::OutputXmlAttribute(
std::ostream* stream,
const std::string& element_name,
const std::string& name,
const std::string& value) {
const std::vector<std::string>& allowed_names =
GetReservedOutputAttributesForElement(element_name);
GTEST_CHECK_(std::find(allowed_na... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x1d0f4
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r14, %rdx
callq 0x2e0b9
cmpq 0x30(%rsp), %rax
jne 0x1d044
leaq 0x15fe2(%rip), %rdx ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::GetReservedOutputAttributesForElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::vector<std::string> GetReservedOutputAttributesForElement(
const std::string& xml_element) {
if (xml_element == "testsuites") {
return ArrayAsVector(kReservedTestSuitesAttributes);
} else if (xml_element == "testsuite") {
return ArrayAsVector(kReservedTestSuiteAttributes);
} else if (xml_e... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x16d20(%rip), %rsi # 0x33e25
movq %r14, %rdi
callq 0x29647
testb %al, %al
je 0x1d125
leaq 0x2e798(%rip), %rsi # 0x4b8b0
movq %rbx, %rdi
callq 0x2b16a
jmp 0x1d1c8
leaq 0x16cd6(%rip), %rsi # 0x33e02
movq %r14, %rdi
callq 0x29647
testb %al,... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x164b3(%rip), %rsi # 0x33e61
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x91d0
leaq 0x164a8(%rip), %rsi # 0x33e6c
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x91d0
movq 0x... | /walterzhaoJR[P]leveldb/third_party/googletest/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x16219(%rip), %rsi # 0x33e02
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x91d0
leaq 0x1620d(%rip), %rsi # 0x33e0c
movq %rbx, %rdi
callq 0x9490
leaq 0x48(%rsp), %rsi
movq %rax, %rdi
callq 0x9430
leaq 0x161a1(... | /walterzhaoJR[P]leveldb/third_party/googletest/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x1d0f4
movq (%rbp), %rdi
movq 0x8(%rbp), %rsi
movq %r15, %rdx
callq 0x2e0b9
cmpq 0x38(%rsp),... | /walterzhaoJR[P]leveldb/third_party/googletest/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 %r14
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rsi, %rax
movq %rdi, %rbx
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq %rcx
leaq 0x1f0(%rsp), %rsi
movq %rax, %rdi
callq 0x1cef3
testb %al, %al
je 0x1f5d4
movl $0x76c, %eax # imm = 0x76C
addl 0x204(%rsp), %eax
leaq 0xc(%rsp), %rs... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonTestSuite(std::ostream*, testing::TestSuite const&) | void JsonUnitTestResultPrinter::PrintJsonTestSuite(
std::ostream* stream, const TestSuite& test_suite) {
const std::string kTestsuite = "testsuite";
const std::string kIndent = Indent(6);
*stream << Indent(4) << "{\n";
OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);
OutputJsonKey(s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x144d2(%rip), %rsi # 0x33e02
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x91d0
leaq 0x58(%rsp), %rdi
pushq $0x6
popq %rsi
callq 0x1f324
leaq 0x10(%rsp), %rdi
pushq $0x4
popq %rsi
callq 0x1... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonTestList(std::ostream*, std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void JsonUnitTestResultPrinter::PrintJsonTestList(
std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
const std::string kTestsuites = "testsuites";
const std::string kIndent = Indent(2);
*stream << "{\n";
int total_tests = 0;
for (auto test_suite : test_suites) {
total_tests += test_s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1408b(%rip), %rsi # 0x33e25
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x91d0
leaq 0x30(%rsp), %rdi
pushq $0x2
popq %rsi
callq 0x1f324
leaq 0x14154(%rip), %rsi # 0x33f11
movq %rbx, %rdi
callq 0x... | /walterzhaoJR[P]leveldb/third_party/googletest/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
je 0x200fa
leaq 0x12ef8(%rip), %rdx # 0x32fb4
leaq 0x10(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x128b, %ecx # imm = 0x128B
callq 0x256d2
movq 0x2bf13(%rip), %rdi # 0x4bfe8
leaq 0x13e69(%rip), ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::OsStackTraceGetter::CurrentStackTrace[abi:cxx11](int, int) | GTEST_LOCK_EXCLUDED_(mutex_) {
#if GTEST_HAS_ABSL
std::string result;
if (max_depth <= 0) {
return result;
}
max_depth = std::min(max_depth, kMaxStackTraceDepth);
std::vector<void*> raw_stack(max_depth);
// Skips the frames requested by the caller, plus this function.
const int raw_stack_size =
... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x13913(%rip), %rsi # 0x33b8e
leaq 0xf(%rsp), %rdx
callq 0x91d0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
cmpq %rbx, %rsi
je 0x20385
movq %rdi, %r14
callq 0x202d8
testq %rax, %rax
je 0x2036a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x10(%r14)
testq %rbx, %rbx
je 0x20385
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::RecordProperty(testing::TestProperty const&) | void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
std::string xml_element;
TestResult* test_result; // TestResult appropriate for property recording.
if (current_test_info_ != nullptr) {
xml_element = "testcase";
test_result = &(current_test_info_->result_);
} else if (current_tes... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)
cmpq $0x0, 0x170(%rdi)
je 0x20497
leaq 0x138c8(%rip), %rsi # 0x33d47
leaq 0x8(%rsp), %rdi
callq 0x9a70
movl $0x90, %edi
addq 0x170(%r14), %rdi
jmp 0x204db
cmpq ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::UnitTest::Run() | int UnitTest::Run() {
const bool in_death_test_child_process =
internal::GTEST_FLAG(internal_run_death_test).length() > 0;
// Google Test implements this protocol for catching that a test
// program exits before returning control to Google Test:
//
// 1. Upon start, Google Test creates a file whose a... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x2c370(%rip) # 0x4c890
je 0x20526
xorl %esi, %esi
jmp 0x20535
leaq 0x13afb(%rip), %rdi # 0x34028
callq 0x9620
movq %rax, %rsi
movq %rsp, %rdi
callq 0x291d8
movq 0x40(%rbx), %rdi
movb 0x2c206(%rip), %al # 0x4c74d
movb %al, 0x258(%rdi)
leaq 0x36(%rip), ... | /walterzhaoJR[P]leveldb/third_party/googletest/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
callq 0x21428
movb $0x1, %r15b
cmpb $0x0, 0x2c19f(%rip) # 0x4c749
jne 0x20945
movl %eax, %ebp
movq %r14, %rdi
callq 0x21208
callq 0x21455
movq 0x238(%r14), %rbx
xorl %edx, %edx
testq %rbx, %rbx
setne %dl
leaq 0x11deb(... | /walterzhaoJR[P]leveldb/third_party/googletest/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
leaq 0x2aa6c(%rip), %rax # 0x4b5c8
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x275e4
leaq 0x30(%r15), %rax
leaq 0x2a7ae(%rip), %rcx # 0x4b328
movq %rcx, 0x30(%r15)
movq %r1... | /walterzhaoJR[P]leveldb/third_party/googletest/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x14df8
leaq 0x114a1(%rip), %rsi # 0x323fc
movq %r14, %rdi
callq 0x29647
testb %al, %al
je 0x20f9f
pushq $0x28
popq %rdi
callq 0x94b0
movq %rax, %r14
movq %rsp, %rdi
callq 0x14e48
movb $0x1, %bpl
movq (%rsp... | /walterzhaoJR[P]leveldb/third_party/googletest/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 0x21212
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x218(%rdi)
callq 0x296c4
cmpq $0x0, 0x238(%rbx)
je 0x2123a
movq 0x1f8(%rbx), %rax
movb $0x0, 0x8(%rax)
movq %rbx, %rdi
callq 0x1a090
movq %rbx, %rdi
callq 0x20f3c
cmpb $0x1, 0x2b567(%rip) # 0x4c7b8
jne 0x21277
leaq 0... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::TempDir[abi:cxx11]() | std::string TempDir() {
#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
#endif
#if 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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x123d0(%rip), %rsi # 0x342f9
leaq 0xf(%rsp), %rdx
callq 0x91d0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::GetThreadCount() | size_t GetThreadCount() {
const std::string filename =
(Message() << "/proc/" << getpid() << "/stat").GetString();
return ReadProcFileField<size_t>(filename, 19);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x250, %rsp # imm = 0x250
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x16112
movq (%rbx), %rbx
leaq 0x10(%rbx), %r14
leaq 0x1101a(%rip), %rsi # 0x34706
movq %r14, %rdi
callq 0x9490
callq 0x97f0
movq %r14, %rdi
movl %eax, %esi
callq 0x9970
leaq 0x11003(%rip), %rsi ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-port.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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0x27c61(%rip), %rdi # 0x4c888
leaq 0xef60(%rip), %rsi # 0x33b8e
callq 0x29647
testb %al, %al
je 0x24c3f
xorl %r14d, %r14d
jmp 0x24d22
orl $-0x1, 0xc(%rsp)
orl $-0x1, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
mov... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-death-test.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 0xf0b6(%rip), %rsi # 0x33edf
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x91d0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x27441
leaq 0x10(%rsp), %rdi
callq 0x9ac8
leaq 0x30(%rsp), %... | /walterzhaoJR[P]leveldb/third_party/googletest/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x24fee
movq (%rsi), %rax
cmpb $0x2f, -0x1(%rax,%rcx)
jne 0x24fee
decq %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x94e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x275f8
leaq 0x8(%rsp), %rdi
callq 0x9ac8
jm... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-filepath.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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rsi, %rdi
callq 0x99f0
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x91f0
leaq 0xa(%rax), %r12
movq %r12, %rdi
callq 0x9040
movq %rax, %r14
leaq 0xf1c0(%rip), %rdx # 0x34713
movq %rax, %rdi
movq %r1... | /walterzhaoJR[P]leveldb/third_party/googletest/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, (%rdi)
cmpl $0x2, %esi
leaq 0xf115(%rip), %rax # 0x34803
leaq 0xf118(%rip), %rcx # 0x3480d
cmoveq %rax, %rcx
cmpl $0x1, %esi
leaq 0xf0f6(%rip), %rax # 0x347f9
cmovneq %rcx, %rax
testl %esi, %esi
leaq 0... | /walterzhaoJR[P]leveldb/third_party/googletest/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x16112
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0xec04(%rip), %rsi # 0x34670
callq 0x9490
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x11c10
leaq 0x18(%rsp), %rdi
movq... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-port.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 == nullptr ? message : std::string(message, stack_trace);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc2b3(%rip), %rsi # 0x32290
movq %r14, %rdi
callq 0x90e0
testq %rax, %rax
je 0x26001
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x111e8
jmp 0x26011
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r1... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-test-part.cc |
testing::operator<<(std::ostream&, testing::TestPartResult const&) | std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
return os << internal::FormatFileLocation(result.file_name(),
result.line_number())
<< " "
<< (result.type() == TestPartResult::kSuccess
? "Success"
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x26038
movq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
movq %rsp, %r15
movq %r15, %rdi
callq 0x19f81
movq %r14, %rdi
movq %r15, %rsi
callq 0x9430
leaq 0xd44c(%rip), %rsi # 0x334a4
movq %rax, %rdi... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-test-part.cc |
testing::TestPartResultArray::GetTestPartResult(int) const | const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
if (index < 0 || index >= size()) {
printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
internal::posix::Abort();
}
return array_[static_cast<size_t>(index)];
} | testl %esi, %esi
js 0x2610f
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
pushq $0x70
popq %rdi
cqto
idivq %rdi
cmpl %esi, %eax
jle 0x2610f
movl %esi, %eax
imulq $0x70, %rax, %rax
addq %rax, %rcx
movq %rcx, %rax
retq
pushq %rax
leaq 0xe803(%rip), %rdi # 0x3491a
xorl %eax, %eax
callq 0x9070
callq 0x283c9
n... | /walterzhaoJR[P]leveldb/third_party/googletest/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movq %r14, %rsi
callq 0x91d0
leaq 0xa0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x9760
leaq 0xa0(%rsp), %rsi
... | /walterzhaoJR[P]leveldb/third_party/googletest/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 %r14
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %r14
movl 0x8(%r14), %edi
callq 0x9aa0
cmpl $-0x1, %eax
jne 0x266b8
callq 0x9060
cmpl $0x4, (%rax)
je 0x265ca
leaq 0xde4b(%rip), %rsi # 0x34438
leaq 0xd8(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x91d0
leaq 0xdd42(%rip), %rdx # 0x34348
... | /walterzhaoJR[P]leveldb/third_party/googletest/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... | Test* CreateTest() override { return factory_(); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %r15
pushq $0x60
popq %rdi
callq 0x94b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x9760
addq $0x28, %r14
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26a96
movq %rsp, %rdi
callq 0x9ac8
movq %rbx, %rax
addq $0x20, %... | /walterzhaoJR[P]leveldb/third_party/googletest/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1933e
leaq 0x24f48(%rip), %rax # 0x4b9f8
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x274f6
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x96e0
movb $0x0, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %ra... | /walterzhaoJR[P]leveldb/third_party/googletest/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
cmpb $0x1, 0x58(%rdi)
jne 0x26b9b
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x16112
leaq 0x38(%r14), %rsi
movq (%rbx), %rbx
leaq 0x10(%rbx), %rdi
callq 0x9430
movq 0x10(%r14), %rdx
movl 0x30(%r14), %ecx
leaq 0xd02e(%rip), %r8 # 0x33b8e
leaq 0x8(%rsp), %rdi
... | /walterzhaoJR[P]leveldb/third_party/googletest/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 %rbx
movq %rdi, %rbx
leaq 0xb506(%rip), %rsi # 0x322b0
leaq 0x2599a(%rip), %rdx # 0x4c74b
callq 0x272b1
testb %al, %al
jne 0x26fc6
leaq 0xb50b(%rip), %rsi # 0x322d0
leaq 0x25980(%rip), %rdx # 0x4c74c
movq %rbx, %rdi
callq 0x272b1
testb %al, %al
jne 0x26fc6
leaq 0xb50d(%rip), %rsi # 0x322f0
... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::HasGoogleTestFlagPrefix(char const*) | static bool HasGoogleTestFlagPrefix(const char* str) {
return (SkipPrefix("--", &str) ||
SkipPrefix("-", &str) ||
SkipPrefix("/", &str)) &&
!SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
(SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
SkipPrefix(GTEST_FLAG_PREFIX_DASH_, ... | pushq %rax
movq %rsp, %rsi
movq %rdi, (%rsi)
leaq 0xd1a3(%rip), %rdi # 0x342f0
callq 0x21d0e
testb %al, %al
jne 0x2717c
leaq 0xd194(%rip), %rdi # 0x342f1
movq %rsp, %rsi
callq 0x21d0e
testb %al, %al
jne 0x2717c
leaq 0xccb3(%rip), %rdi # 0x33e23
movq %rsp, %rsi
callq 0x21d0e
testb %al, %al
je 0x2718f
leaq... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::PrintColorEncoded(char const*) | static void PrintColorEncoded(const char* str) {
GTestColor color = GTestColor::kDefault; // The current color.
// Conceptually, we split the string into segments divided by escape
// sequences. Then we print one segment at a time. At the end of
// each iteration, the str pointer advances to the beginning o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0xb310(%rip), %r15 # 0x324e0
pushq $0x40
popq %rbx
leaq 0x8(%rsp), %r14
xorl %ebp, %ebp
movq %r15, %r12
movq %r12, %rdi
movl %ebx, %esi
callq 0x91c0
testq %rax, %rax
je 0x2727a
movq %rax, %r13
leaq 0x18(%rsp), %rax
movq %rax, 0... | /walterzhaoJR[P]leveldb/third_party/googletest/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 %rbx
movq %rdx, %rbx
pushq $0x1
popq %rdx
callq 0x21dea
testq %rax, %rax
je 0x272d9
movzbl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x30, %edx
je 0x272d7
cmpl $0x66, %edx
je 0x272d7
cmpb $0x46, %dl
setne %cl
movb %cl, (%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::PrintAsStringLiteralTo(wchar_t, std::ostream*) | static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
switch (c) {
case L'\'':
*os << "'";
return kAsIs;
case L'"':
*os << "\\\"";
return kSpecialEscape;
default:
return PrintAsCharLiteralTo<wchar_t>(c, os);
}
} | pushq %rax
cmpl $0x22, %edi
je 0x27406
cmpl $0x27, %edi
jne 0x2741d
leaq 0xbe33(%rip), %rax # 0x3322a
movq %rsi, %rdi
movq %rax, %rsi
callq 0x9490
xorl %eax, %eax
jmp 0x2741b
leaq 0xe28b(%rip), %rax # 0x35698
movq %rsi, %rdi
movq %rax, %rsi
callq 0x9490
pushq $0x2
popq %rax
popq %rcx
retq
popq %rax
jmp 0x272e... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-printers.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 0x9490
movq %rbx, %rax
popq %rbx
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [13]>(char const (&) [13]) | 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 0x9490
movq %rbx, %rax
popq %rbx
retq
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest-message.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 0x16112
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x9490
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x11b8e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x279d8
movq (%rdi), %rax
callq... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest.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 0x9490
movq %rbx, %rax
popq %rbx
retq
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [32]>(char const (&) [32]) | 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 0x9490
movq %rbx, %rax
popq %rbx
retq
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest-message.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::internal::StreamableToString<long>(long const&) | std::string StreamableToString(const T& streamable) {
return (Message() << streamable).GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x16112
movq %r15, %rdi
movq %r14, %rsi
callq 0x2c79e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x162d2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x28f33
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest-message.h |
testing::internal::UnitTestImpl::GetTestSuite(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 0x29133
movq 0xd0(%rdi), %rax
movq 0xd8(%rdi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl %esi, %ecx
jle 0x29133
movl %esi, %ecx
cmpl $0x0, (%rax,%rcx,4)
js 0x29133
movq 0xb8(%rdi), %rax
movq (%rax,%rcx,8), %rax
retq
xorl %eax, %eax
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-internal-inl.h |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<wchar_t>(int*, wchar_t**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseBoolFlag;
using internal::ParseInt32Flag;
using internal::ParseStringFlag;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r12
leaq 0x8(%rsp), %r15
cmpl (%r14), %r12d
jge 0x29d6d
movslq %r12d, %r13
leaq (%rbx,%r13,8), %rsi
movq %r15, %rdi
callq 0x2f228
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x26d9f
testb %... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::Arguments::~Arguments() | ~Arguments() {
for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
++i) {
free(*i);
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rbx), %r14
je 0x2a06e
movq (%r14), %rdi
callq 0x9600
addq $0x8, %r14
jmp 0x2a05a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2c28e
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-death-test.cc |
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.