yuzu/breakpad
1
0
Fork 0
mirror of https://github.com/yuzu-emu/breakpad.git synced 2025-07-08 01:50:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Correct compilation warning.

Browse source 
1) Modify src/common/mac/macho_walker.cc to remove a signed  vs unsigned comparison.

 2) Replace mktemp in test using AutoTmpDir that has been moved from client/mac/tests to common/tests.
Review URL: http://breakpad.appspot.com/328001

git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@888 4c0a9323-5329-0410-9bdc-e9ce6186880e
This commit is contained in:
qsr@chromium.org 2011-11-23 14:22:05 +00:00
parent 84571a2b91
commit bad70be095
8 changed files with 157 additions and 133 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

56
src/client/linux/handler/exception_handler_unittest.cc
View file

@ -44,17 +44,12 @@
#include "common/linux/eintr_wrapper.h" #include "common/linux/eintr_wrapper.h"
#include "common/linux/file_id.h" #include "common/linux/file_id.h"
#include "common/linux/linux_libc_support.h" #include "common/linux/linux_libc_support.h"
#include "common/tests/auto_tempdir.h"
#include "third_party/lss/linux_syscall_support.h" #include "third_party/lss/linux_syscall_support.h"
#include "google_breakpad/processor/minidump.h" #include "google_breakpad/processor/minidump.h"
using namespace google_breakpad; using namespace google_breakpad;
#if !defined(__ANDROID__)
#define TEMPDIR "/tmp"
#else
#define TEMPDIR "/data/local/tmp"
#endif
// Length of a formatted GUID string = // Length of a formatted GUID string =
// sizeof(MDGUID) * 2 + 4 (for dashes) + 1 (null terminator) // sizeof(MDGUID) * 2 + 4 (for dashes) + 1 (null terminator)
const int kGUIDStringSize = 37; const int kGUIDStringSize = 37;
@ -79,7 +74,8 @@ class ExceptionHandlerTest : public ::testing::Test {
}; };
TEST(ExceptionHandlerTest, Simple) { TEST(ExceptionHandlerTest, Simple) {
ExceptionHandler handler(TEMPDIR, NULL, NULL, NULL, true); AutoTempDir temp_dir;
ExceptionHandler handler(temp_dir.path(), NULL, NULL, NULL, true);
} }
static bool DoneCallback(const char* dump_path, static bool DoneCallback(const char* dump_path,
@ -99,13 +95,14 @@ static bool DoneCallback(const char* dump_path,
} }
TEST(ExceptionHandlerTest, ChildCrash) { TEST(ExceptionHandlerTest, ChildCrash) {
AutoTempDir temp_dir;
int fds[2]; int fds[2];
ASSERT_NE(pipe(fds), -1); ASSERT_NE(pipe(fds), -1);
const pid_t child = fork(); const pid_t child = fork();
if (child == 0) { if (child == 0) {
close(fds[0]); close(fds[0]);
ExceptionHandler handler(TEMPDIR, NULL, DoneCallback, (void*) fds[1], ExceptionHandler handler(temp_dir.path(), NULL, DoneCallback, (void*) fds[1],
true); true);
*reinterpret_cast<volatile int*>(NULL) = 0; *reinterpret_cast<volatile int*>(NULL) = 0;
} }
@ -133,7 +130,7 @@ TEST(ExceptionHandlerTest, ChildCrash) {
filename[len] = 0; filename[len] = 0;
close(fds[0]); close(fds[0]);
const std::string minidump_filename = std::string(TEMPDIR) + "/" + filename + const std::string minidump_filename = temp_dir.path() + "/" + filename +
".dmp"; ".dmp";
struct stat st; struct stat st;
@ -145,6 +142,7 @@ TEST(ExceptionHandlerTest, ChildCrash) {
// Test that memory around the instruction pointer is written // Test that memory around the instruction pointer is written
// to the dump as a MinidumpMemoryRegion. // to the dump as a MinidumpMemoryRegion.
TEST(ExceptionHandlerTest, InstructionPointerMemory) { TEST(ExceptionHandlerTest, InstructionPointerMemory) {
AutoTempDir temp_dir;
int fds[2]; int fds[2];
ASSERT_NE(pipe(fds), -1); ASSERT_NE(pipe(fds), -1);
@ -158,8 +156,8 @@ TEST(ExceptionHandlerTest, InstructionPointerMemory) {
const pid_t child = fork(); const pid_t child = fork();
if (child == 0) { if (child == 0) {
close(fds[0]); close(fds[0]);
ExceptionHandler handler(TEMPDIR, NULL, DoneCallback, (void*) fds[1], ExceptionHandler handler(temp_dir.path(), NULL, DoneCallback,
true); (void*) fds[1], true);
// Get some executable memory. // Get some executable memory.
char* memory = char* memory =
reinterpret_cast<char*>(mmap(NULL, reinterpret_cast<char*>(mmap(NULL,
@ -206,7 +204,7 @@ TEST(ExceptionHandlerTest, InstructionPointerMemory) {
filename[len] = 0; filename[len] = 0;
close(fds[0]); close(fds[0]);
const std::string minidump_filename = std::string(TEMPDIR) + "/" + filename + const std::string minidump_filename = temp_dir.path() + "/" + filename +
".dmp"; ".dmp";
struct stat st; struct stat st;
@ -269,6 +267,7 @@ TEST(ExceptionHandlerTest, InstructionPointerMemory) {
// Test that the memory region around the instruction pointer is // Test that the memory region around the instruction pointer is
// bounded correctly on the low end. // bounded correctly on the low end.
TEST(ExceptionHandlerTest, InstructionPointerMemoryMinBound) { TEST(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
AutoTempDir temp_dir;
int fds[2]; int fds[2];
ASSERT_NE(pipe(fds), -1); ASSERT_NE(pipe(fds), -1);
@ -282,8 +281,8 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
const pid_t child = fork(); const pid_t child = fork();
if (child == 0) { if (child == 0) {
close(fds[0]); close(fds[0]);
ExceptionHandler handler(TEMPDIR, NULL, DoneCallback, (void*) fds[1], ExceptionHandler handler(temp_dir.path(), NULL, DoneCallback,
true); (void*) fds[1], true);
// Get some executable memory. // Get some executable memory.
char* memory = char* memory =
reinterpret_cast<char*>(mmap(NULL, reinterpret_cast<char*>(mmap(NULL,
@ -330,7 +329,7 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
filename[len] = 0; filename[len] = 0;
close(fds[0]); close(fds[0]);
const std::string minidump_filename = std::string(TEMPDIR) + "/" + filename + const std::string minidump_filename = temp_dir.path() + "/" + filename +
".dmp"; ".dmp";
struct stat st; struct stat st;
@ -390,6 +389,7 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
// Test that the memory region around the instruction pointer is // Test that the memory region around the instruction pointer is
// bounded correctly on the high end. // bounded correctly on the high end.
TEST(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) { TEST(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
AutoTempDir temp_dir;
int fds[2]; int fds[2];
ASSERT_NE(pipe(fds), -1); ASSERT_NE(pipe(fds), -1);
@ -406,8 +406,8 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
const pid_t child = fork(); const pid_t child = fork();
if (child == 0) { if (child == 0) {
close(fds[0]); close(fds[0]);
ExceptionHandler handler(TEMPDIR, NULL, DoneCallback, (void*) fds[1], ExceptionHandler handler(temp_dir.path(), NULL, DoneCallback,
true); (void*) fds[1], true);
// Get some executable memory. // Get some executable memory.
char* memory = char* memory =
reinterpret_cast<char*>(mmap(NULL, reinterpret_cast<char*>(mmap(NULL,
@ -454,7 +454,7 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
filename[len] = 0; filename[len] = 0;
close(fds[0]); close(fds[0]);
const std::string minidump_filename = std::string(TEMPDIR) + "/" + filename + const std::string minidump_filename = temp_dir.path() + "/" + filename +
".dmp"; ".dmp";
struct stat st; struct stat st;
@ -515,6 +515,7 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
// Ensure that an extra memory block doesn't get added when the // Ensure that an extra memory block doesn't get added when the
// instruction pointer is not in mapped memory. // instruction pointer is not in mapped memory.
TEST(ExceptionHandlerTest, InstructionPointerMemoryNullPointer) { TEST(ExceptionHandlerTest, InstructionPointerMemoryNullPointer) {
AutoTempDir temp_dir;
int fds[2]; int fds[2];
ASSERT_NE(pipe(fds), -1); ASSERT_NE(pipe(fds), -1);
@ -522,8 +523,8 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryNullPointer) {
const pid_t child = fork(); const pid_t child = fork();
if (child == 0) { if (child == 0) {
close(fds[0]); close(fds[0]);
ExceptionHandler handler(TEMPDIR, NULL, DoneCallback, (void*) fds[1], ExceptionHandler handler(temp_dir.path(), NULL, DoneCallback,
true); (void*) fds[1], true);
// Try calling a NULL pointer. // Try calling a NULL pointer.
typedef void (*void_function)(void); typedef void (*void_function)(void);
void_function memory_function = void_function memory_function =
@ -554,7 +555,7 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryNullPointer) {
filename[len] = 0; filename[len] = 0;
close(fds[0]); close(fds[0]);
const std::string minidump_filename = std::string(TEMPDIR) + "/" + filename + const std::string minidump_filename = temp_dir.path() + "/" + filename +
".dmp"; ".dmp";
struct stat st; struct stat st;
@ -629,7 +630,8 @@ TEST(ExceptionHandlerTest, ModuleInfo) {
ASSERT_TRUE(memory); ASSERT_TRUE(memory);
string minidump_filename; string minidump_filename;
ExceptionHandler handler(TEMPDIR, NULL, SimpleCallback, AutoTempDir temp_dir;
ExceptionHandler handler(temp_dir.path(), NULL, SimpleCallback,
(void*)&minidump_filename, true); (void*)&minidump_filename, true);
// Add info about the anonymous memory mapping. // Add info about the anonymous memory mapping.
handler.AddMappingInfo(kMemoryName, handler.AddMappingInfo(kMemoryName,
@ -756,9 +758,9 @@ TEST(ExceptionHandlerTest, ExternalDumper) {
ASSERT_NE(crashing_pid, -1); ASSERT_NE(crashing_pid, -1);
ASSERT_NE(signal_fd, -1); ASSERT_NE(signal_fd, -1);
char templ[] = TEMPDIR "/exception-handler-unittest-XXXXXX"; AutoTempDir temp_dir;
mktemp(templ); std::string templ = temp_dir.path() + "/exception-handler-unittest";
ASSERT_TRUE(WriteMinidump(templ, crashing_pid, context, ASSERT_TRUE(WriteMinidump(templ.c_str(), crashing_pid, context,
kCrashContextSize)); kCrashContextSize));
static const char b = 0; static const char b = 0;
HANDLE_EINTR(write(signal_fd, &b, 1)); HANDLE_EINTR(write(signal_fd, &b, 1));
@ -769,7 +771,7 @@ TEST(ExceptionHandlerTest, ExternalDumper) {
ASSERT_EQ(WTERMSIG(status), SIGSEGV); ASSERT_EQ(WTERMSIG(status), SIGSEGV);
struct stat st; struct stat st;
ASSERT_EQ(stat(templ, &st), 0); ASSERT_EQ(stat(templ.c_str(), &st), 0);
ASSERT_GT(st.st_size, 0u); ASSERT_GT(st.st_size, 0u);
unlink(templ); unlink(templ.c_str());
} }

72
src/client/linux/minidump_writer/minidump_writer_unittest.cc
View file

@ -42,16 +42,11 @@
#include "client/linux/minidump_writer/minidump_writer.h" #include "client/linux/minidump_writer/minidump_writer.h"
#include "common/linux/eintr_wrapper.h" #include "common/linux/eintr_wrapper.h"
#include "common/linux/file_id.h" #include "common/linux/file_id.h"
#include "common/tests/auto_tempdir.h"
#include "google_breakpad/processor/minidump.h" #include "google_breakpad/processor/minidump.h"
using namespace google_breakpad; using namespace google_breakpad;
#if !defined(__ANDROID__)
#define TEMPDIR "/tmp"
#else
#define TEMPDIR "/data/local/tmp"
#endif
// Length of a formatted GUID string = // Length of a formatted GUID string =
// sizeof(MDGUID) * 2 + 4 (for dashes) + 1 (null terminator) // sizeof(MDGUID) * 2 + 4 (for dashes) + 1 (null terminator)
const int kGUIDStringSize = 37; const int kGUIDStringSize = 37;
@ -77,15 +72,14 @@ TEST(MinidumpWriterTest, Setup) {
ExceptionHandler::CrashContext context; ExceptionHandler::CrashContext context;
memset(&context, 0, sizeof(context)); memset(&context, 0, sizeof(context));
char templ[] = TEMPDIR "/minidump-writer-unittest-XXXXXX"; AutoTempDir temp_dir;
mktemp(templ); std::string templ = temp_dir.path() + "/minidump-writer-unittest";
// Set a non-zero tid to avoid tripping asserts. // Set a non-zero tid to avoid tripping asserts.
context.tid = 1; context.tid = 1;
ASSERT_TRUE(WriteMinidump(templ, child, &context, sizeof(context))); ASSERT_TRUE(WriteMinidump(templ.c_str(), child, &context, sizeof(context)));
struct stat st; struct stat st;
ASSERT_EQ(stat(templ, &st), 0); ASSERT_EQ(stat(templ.c_str(), &st), 0);
ASSERT_GT(st.st_size, 0u); ASSERT_GT(st.st_size, 0u);
unlink(templ);
close(fds[1]); close(fds[1]);
} }
@ -143,8 +137,8 @@ TEST(MinidumpWriterTest, MappingInfo) {
memset(&context, 0, sizeof(context)); memset(&context, 0, sizeof(context));
context.tid = 1; context.tid = 1;
char templ[] = TEMPDIR "/minidump-writer-unittest-XXXXXX"; AutoTempDir temp_dir;
mktemp(templ); std::string templ = temp_dir.path() + "/minidump-writer-unittest";
// Add information about the mapped memory. // Add information about the mapped memory.
MappingInfo info; MappingInfo info;
@ -158,12 +152,13 @@ TEST(MinidumpWriterTest, MappingInfo) {
mapping.first = info; mapping.first = info;
memcpy(mapping.second, kModuleGUID, sizeof(MDGUID)); memcpy(mapping.second, kModuleGUID, sizeof(MDGUID));
mappings.push_back(mapping); mappings.push_back(mapping);
ASSERT_TRUE(WriteMinidump(templ, child, &context, sizeof(context), mappings)); ASSERT_TRUE(WriteMinidump(templ.c_str(), child, &context, sizeof(context),
mappings));
// Read the minidump. Load the module list, and ensure that // Read the minidump. Load the module list, and ensure that
// the mmap'ed |memory| is listed with the given module name // the mmap'ed |memory| is listed with the given module name
// and debug ID. // and debug ID.
Minidump minidump(templ); Minidump minidump(templ.c_str());
ASSERT_TRUE(minidump.Read()); ASSERT_TRUE(minidump.Read());
MinidumpModuleList* module_list = minidump.GetModuleList(); MinidumpModuleList* module_list = minidump.GetModuleList();
@ -177,7 +172,6 @@ TEST(MinidumpWriterTest, MappingInfo) {
EXPECT_EQ(kMemoryName, module->code_file()); EXPECT_EQ(kMemoryName, module->code_file());
EXPECT_EQ(module_identifier, module->debug_identifier()); EXPECT_EQ(module_identifier, module->debug_identifier());
unlink(templ);
close(fds[1]); close(fds[1]);
} }
@ -211,11 +205,11 @@ TEST(MinidumpWriterTest, MappingInfoContained) {
module_identifier += "0"; module_identifier += "0";
// mmap a file // mmap a file
char tempfile[] = TEMPDIR "/minidump-writer-unittest-temp-XXXXXX"; AutoTempDir temp_dir;
mktemp(tempfile); std::string tempfile = temp_dir.path() + "/minidump-writer-unittest-temp";
int fd = open(tempfile, O_RDWR | O_CREAT, 0); int fd = open(tempfile.c_str(), O_RDWR | O_CREAT, 0);
ASSERT_NE(-1, fd); ASSERT_NE(-1, fd);
unlink(tempfile); unlink(tempfile.c_str());
// fill with zeros // fill with zeros
char buffer[kMemorySize]; char buffer[kMemorySize];
memset(buffer, 0, kMemorySize); memset(buffer, 0, kMemorySize);
@ -247,8 +241,7 @@ TEST(MinidumpWriterTest, MappingInfoContained) {
memset(&context, 0, sizeof(context)); memset(&context, 0, sizeof(context));
context.tid = 1; context.tid = 1;
char dumpfile[] = TEMPDIR "/minidump-writer-unittest-XXXXXX"; std::string dumpfile = temp_dir.path() + "/minidump-writer-unittest";
mktemp(dumpfile);
// Add information about the mapped memory. Report it as being larger than // Add information about the mapped memory. Report it as being larger than
// it actually is. // it actually is.
@ -264,12 +257,13 @@ TEST(MinidumpWriterTest, MappingInfoContained) {
memcpy(mapping.second, kModuleGUID, sizeof(MDGUID)); memcpy(mapping.second, kModuleGUID, sizeof(MDGUID));
mappings.push_back(mapping); mappings.push_back(mapping);
ASSERT_TRUE( ASSERT_TRUE(
WriteMinidump(dumpfile, child, &context, sizeof(context), mappings)); WriteMinidump(dumpfile.c_str(), child, &context, sizeof(context),
mappings));
// Read the minidump. Load the module list, and ensure that // Read the minidump. Load the module list, and ensure that
// the mmap'ed |memory| is listed with the given module name // the mmap'ed |memory| is listed with the given module name
// and debug ID. // and debug ID.
Minidump minidump(dumpfile); Minidump minidump(dumpfile.c_str());
ASSERT_TRUE(minidump.Read()); ASSERT_TRUE(minidump.Read());
MinidumpModuleList* module_list = minidump.GetModuleList(); MinidumpModuleList* module_list = minidump.GetModuleList();
@ -283,7 +277,6 @@ TEST(MinidumpWriterTest, MappingInfoContained) {
EXPECT_EQ(kMemoryName, module->code_file()); EXPECT_EQ(kMemoryName, module->code_file());
EXPECT_EQ(module_identifier, module->debug_identifier()); EXPECT_EQ(module_identifier, module->debug_identifier());
unlink(dumpfile);
close(fds[1]); close(fds[1]);
} }
@ -308,12 +301,13 @@ TEST(MinidumpWriterTest, DeletedBinary) {
helper_path += "linux_dumper_unittest_helper"; helper_path += "linux_dumper_unittest_helper";
// Copy binary to a temp file. // Copy binary to a temp file.
char binpath[] = TEMPDIR "/linux-dumper-unittest-helper-XXXXXX"; AutoTempDir temp_dir;
mktemp(binpath); std::string binpath = temp_dir.path() + "/linux-dumper-unittest-helper";
char cmdline[2 * PATH_MAX]; char cmdline[2 * PATH_MAX];
sprintf(cmdline, "/bin/cp \"%s\" \"%s\"", helper_path.c_str(), binpath); sprintf(cmdline, "/bin/cp \"%s\" \"%s\"", helper_path.c_str(),
binpath.c_str());
ASSERT_EQ(0, system(cmdline)); ASSERT_EQ(0, system(cmdline));
ASSERT_EQ(0, chmod(binpath, 0755)); ASSERT_EQ(0, chmod(binpath.c_str(), 0755));
int fds[2]; int fds[2];
ASSERT_NE(-1, pipe(fds)); ASSERT_NE(-1, pipe(fds));
@ -326,8 +320,8 @@ TEST(MinidumpWriterTest, DeletedBinary) {
// Pass the pipe fd and the number of threads as arguments. // Pass the pipe fd and the number of threads as arguments.
char pipe_fd_string[8]; char pipe_fd_string[8];
sprintf(pipe_fd_string, "%d", fds[1]); sprintf(pipe_fd_string, "%d", fds[1]);
execl(binpath, execl(binpath.c_str(),
binpath, binpath.c_str(),
pipe_fd_string, pipe_fd_string,
kNumberOfThreadsArgument, kNumberOfThreadsArgument,
NULL); NULL);
@ -348,32 +342,32 @@ TEST(MinidumpWriterTest, DeletedBinary) {
// Child is ready now. // Child is ready now.
// Unlink the test binary. // Unlink the test binary.
unlink(binpath); unlink(binpath.c_str());
ExceptionHandler::CrashContext context; ExceptionHandler::CrashContext context;
memset(&context, 0, sizeof(context)); memset(&context, 0, sizeof(context));
char templ[] = TEMPDIR "/minidump-writer-unittest-XXXXXX"; std::string templ = temp_dir.path() + "/minidump-writer-unittest";
mktemp(templ);
// Set a non-zero tid to avoid tripping asserts. // Set a non-zero tid to avoid tripping asserts.
context.tid = 1; context.tid = 1;
ASSERT_TRUE(WriteMinidump(templ, child_pid, &context, sizeof(context))); ASSERT_TRUE(WriteMinidump(templ.c_str(), child_pid, &context,
sizeof(context)));
kill(child_pid, SIGKILL); kill(child_pid, SIGKILL);
struct stat st; struct stat st;
ASSERT_EQ(stat(templ, &st), 0); ASSERT_EQ(stat(templ.c_str(), &st), 0);
ASSERT_GT(st.st_size, 0u); ASSERT_GT(st.st_size, 0u);
Minidump minidump(templ); Minidump minidump(templ.c_str());
ASSERT_TRUE(minidump.Read()); ASSERT_TRUE(minidump.Read());
// Check that the main module filename is correct. // Check that the main module filename is correct.
MinidumpModuleList* module_list = minidump.GetModuleList(); MinidumpModuleList* module_list = minidump.GetModuleList();
ASSERT_TRUE(module_list); ASSERT_TRUE(module_list);
const MinidumpModule* module = module_list->GetMainModule(); const MinidumpModule* module = module_list->GetMainModule();
EXPECT_STREQ(binpath, module->code_file().c_str()); EXPECT_STREQ(binpath.c_str(), module->code_file().c_str());
// Check that the file ID is correct. // Check that the file ID is correct.
FileID fileid(helper_path.c_str()); FileID fileid(helper_path.c_str());
uint8_t identifier[sizeof(MDGUID)]; uint8_t identifier[sizeof(MDGUID)];
@ -391,6 +385,4 @@ TEST(MinidumpWriterTest, DeletedBinary) {
// which is always zero on Linux. // which is always zero on Linux.
module_identifier += "0"; module_identifier += "0";
EXPECT_EQ(module_identifier, module->debug_identifier()); EXPECT_EQ(module_identifier, module->debug_identifier());
unlink(templ);
} }

52
src/client/mac/tests/crash_generation_server_test.cc
View file

@ -43,8 +43,8 @@
#include "client/mac/crash_generation/crash_generation_client.h" #include "client/mac/crash_generation/crash_generation_client.h"
#include "client/mac/crash_generation/crash_generation_server.h" #include "client/mac/crash_generation/crash_generation_server.h"
#include "client/mac/handler/exception_handler.h" #include "client/mac/handler/exception_handler.h"
#include "client/mac/tests/auto_tempdir.h"
#include "client/mac/tests/spawn_child_process.h" #include "client/mac/tests/spawn_child_process.h"
#include "common/tests/auto_tempdir.h"
#include "google_breakpad/processor/minidump.h" #include "google_breakpad/processor/minidump.h"
namespace google_breakpad { namespace google_breakpad {
@ -111,12 +111,12 @@ TEST_F(CrashGenerationServerTest, testStartStopServer) {
// Test without actually dumping // Test without actually dumping
TEST_F(CrashGenerationServerTest, testRequestDumpNoDump) { TEST_F(CrashGenerationServerTest, testRequestDumpNoDump) {
CrashGenerationServer server(mach_port_name, CrashGenerationServer server(mach_port_name,
NULL, // dump callback NULL, // dump callback
NULL, // dump context NULL, // dump context
NULL, // exit callback NULL, // exit callback
NULL, // exit context NULL, // exit context
false, // don't generate dumps false, // don't generate dumps
temp_dir.path); // dump path temp_dir.path()); // dump path
ASSERT_TRUE(server.Start()); ASSERT_TRUE(server.Start());
pid_t pid = fork(); pid_t pid = fork();
@ -133,7 +133,7 @@ TEST_F(CrashGenerationServerTest, testRequestDumpNoDump) {
EXPECT_EQ(0, WEXITSTATUS(ret)); EXPECT_EQ(0, WEXITSTATUS(ret));
EXPECT_TRUE(server.Stop()); EXPECT_TRUE(server.Stop());
// check that no minidump was written // check that no minidump was written
string pattern = temp_dir.path + "/*"; string pattern = temp_dir.path() + "/*";
glob_t dirContents; glob_t dirContents;
ret = glob(pattern.c_str(), GLOB_NOSORT, NULL, &dirContents); ret = glob(pattern.c_str(), GLOB_NOSORT, NULL, &dirContents);
EXPECT_EQ(GLOB_NOMATCH, ret); EXPECT_EQ(GLOB_NOMATCH, ret);
@ -161,12 +161,12 @@ void *RequestDump(void *context) {
// Test that actually writing a minidump works // Test that actually writing a minidump works
TEST_F(CrashGenerationServerTest, testRequestDump) { TEST_F(CrashGenerationServerTest, testRequestDump) {
CrashGenerationServer server(mach_port_name, CrashGenerationServer server(mach_port_name,
dumpCallback, // dump callback dumpCallback, // dump callback
this, // dump context this, // dump context
NULL, // exit callback NULL, // exit callback
NULL, // exit context NULL, // exit context
true, // generate dumps true, // generate dumps
temp_dir.path); // dump path temp_dir.path()); // dump path
ASSERT_TRUE(server.Start()); ASSERT_TRUE(server.Start());
pid_t pid = fork(); pid_t pid = fork();
@ -209,12 +209,12 @@ static void Crasher() {
// the parent. // the parent.
TEST_F(CrashGenerationServerTest, testChildProcessCrash) { TEST_F(CrashGenerationServerTest, testChildProcessCrash) {
CrashGenerationServer server(mach_port_name, CrashGenerationServer server(mach_port_name,
dumpCallback, // dump callback dumpCallback, // dump callback
this, // dump context this, // dump context
NULL, // exit callback NULL, // exit callback
NULL, // exit context NULL, // exit context
true, // generate dumps true, // generate dumps
temp_dir.path); // dump path temp_dir.path()); // dump path
ASSERT_TRUE(server.Start()); ASSERT_TRUE(server.Start());
pid_t pid = fork(); pid_t pid = fork();
@ -270,12 +270,12 @@ TEST_F(CrashGenerationServerTest, testChildProcessCrash) {
// produces a valid minidump. // produces a valid minidump.
TEST_F(CrashGenerationServerTest, testChildProcessCrashCrossArchitecture) { TEST_F(CrashGenerationServerTest, testChildProcessCrashCrossArchitecture) {
CrashGenerationServer server(mach_port_name, CrashGenerationServer server(mach_port_name,
dumpCallback, // dump callback dumpCallback, // dump callback
this, // dump context this, // dump context
NULL, // exit callback NULL, // exit callback
NULL, // exit context NULL, // exit context
true, // generate dumps true, // generate dumps
temp_dir.path); // dump path temp_dir.path()); // dump path
ASSERT_TRUE(server.Start()); ASSERT_TRUE(server.Start());
// Spawn a child process // Spawn a child process

28
src/client/mac/tests/exception_handler_test.cc
View file

@ -36,8 +36,8 @@
#include "breakpad_googletest_includes.h" #include "breakpad_googletest_includes.h"
#include "client/mac/handler/exception_handler.h" #include "client/mac/handler/exception_handler.h"
#include "client/mac/tests/auto_tempdir.h"
#include "common/mac/MachIPC.h" #include "common/mac/MachIPC.h"
#include "common/tests/auto_tempdir.h"
#include "google_breakpad/processor/minidump.h" #include "google_breakpad/processor/minidump.h"
namespace google_breakpad { namespace google_breakpad {
@ -103,7 +103,7 @@ TEST_F(ExceptionHandlerTest, InProcess) {
if (pid == 0) { if (pid == 0) {
// In the child process. // In the child process.
close(fds[0]); close(fds[0]);
ExceptionHandler eh(tempDir.path, NULL, MDCallback, &fds[1], true, NULL); ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
// crash // crash
SoonToCrash(); SoonToCrash();
// not reached // not reached
@ -141,7 +141,8 @@ static bool DumpNameMDCallback(const char *dump_dir, const char *file_name,
} }
TEST_F(ExceptionHandlerTest, WriteMinidump) { TEST_F(ExceptionHandlerTest, WriteMinidump) {
ExceptionHandler eh(tempDir.path, NULL, DumpNameMDCallback, this, true, NULL); ExceptionHandler eh(tempDir.path(), NULL, DumpNameMDCallback, this, true,
NULL);
ASSERT_TRUE(eh.WriteMinidump()); ASSERT_TRUE(eh.WriteMinidump());
// Ensure that minidump file exists and is > 0 bytes. // Ensure that minidump file exists and is > 0 bytes.
@ -159,7 +160,8 @@ TEST_F(ExceptionHandlerTest, WriteMinidump) {
} }
TEST_F(ExceptionHandlerTest, WriteMinidumpWithException) { TEST_F(ExceptionHandlerTest, WriteMinidumpWithException) {
ExceptionHandler eh(tempDir.path, NULL, DumpNameMDCallback, this, true, NULL); ExceptionHandler eh(tempDir.path(), NULL, DumpNameMDCallback, this, true,
NULL);
ASSERT_TRUE(eh.WriteMinidump(true)); ASSERT_TRUE(eh.WriteMinidump(true));
// Ensure that minidump file exists and is > 0 bytes. // Ensure that minidump file exists and is > 0 bytes.
@ -227,10 +229,10 @@ TEST_F(ExceptionHandlerTest, DumpChildProcess) {
// Write a minidump of the child process. // Write a minidump of the child process.
bool result = ExceptionHandler::WriteMinidumpForChild(child_task, bool result = ExceptionHandler::WriteMinidumpForChild(child_task,
child_thread, child_thread,
tempDir.path, tempDir.path(),
DumpNameMDCallback, DumpNameMDCallback,
this); this);
ASSERT_EQ(true, result); ASSERT_EQ(true, result);
// Ensure that minidump file exists and is > 0 bytes. // Ensure that minidump file exists and is > 0 bytes.
@ -267,7 +269,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemory) {
pid_t pid = fork(); pid_t pid = fork();
if (pid == 0) { if (pid == 0) {
close(fds[0]); close(fds[0]);
ExceptionHandler eh(tempDir.path, NULL, MDCallback, &fds[1], true, NULL); ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
// Get some executable memory. // Get some executable memory.
char* memory = char* memory =
reinterpret_cast<char*>(mmap(NULL, reinterpret_cast<char*>(mmap(NULL,
@ -379,7 +381,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
pid_t pid = fork(); pid_t pid = fork();
if (pid == 0) { if (pid == 0) {
close(fds[0]); close(fds[0]);
ExceptionHandler eh(tempDir.path, NULL, MDCallback, &fds[1], true, NULL); ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
// Get some executable memory. // Get some executable memory.
char* memory = char* memory =
reinterpret_cast<char*>(mmap(NULL, reinterpret_cast<char*>(mmap(NULL,
@ -491,7 +493,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
pid_t pid = fork(); pid_t pid = fork();
if (pid == 0) { if (pid == 0) {
close(fds[0]); close(fds[0]);
ExceptionHandler eh(tempDir.path, NULL, MDCallback, &fds[1], true, NULL); ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
// Get some executable memory. // Get some executable memory.
char* memory = char* memory =
reinterpret_cast<char*>(mmap(NULL, reinterpret_cast<char*>(mmap(NULL,
@ -594,7 +596,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryNullPointer) {
pid_t pid = fork(); pid_t pid = fork();
if (pid == 0) { if (pid == 0) {
close(fds[0]); close(fds[0]);
ExceptionHandler eh(tempDir.path, NULL, MDCallback, &fds[1], true, NULL); ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
// Try calling a NULL pointer. // Try calling a NULL pointer.
typedef void (*void_function)(void); typedef void (*void_function)(void);
void_function memory_function = void_function memory_function =
@ -651,7 +653,7 @@ TEST_F(ExceptionHandlerTest, MemoryListMultipleThreads) {
pid_t pid = fork(); pid_t pid = fork();
if (pid == 0) { if (pid == 0) {
close(fds[0]); close(fds[0]);
ExceptionHandler eh(tempDir.path, NULL, MDCallback, &fds[1], true, NULL); ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
// Run an extra thread so >2 memory regions will be written. // Run an extra thread so >2 memory regions will be written.
pthread_t junk_thread; pthread_t junk_thread;

14
src/client/mac/tests/minidump_generator_test.cc
View file

@ -41,9 +41,9 @@
#include "breakpad_googletest_includes.h" #include "breakpad_googletest_includes.h"
#include "client/mac/handler/minidump_generator.h" #include "client/mac/handler/minidump_generator.h"
#include "client/mac/tests/auto_tempdir.h"
#include "client/mac/tests/spawn_child_process.h" #include "client/mac/tests/spawn_child_process.h"
#include "common/mac/MachIPC.h" #include "common/mac/MachIPC.h"
#include "common/tests/auto_tempdir.h"
#include "google_breakpad/processor/minidump.h" #include "google_breakpad/processor/minidump.h"
namespace google_breakpad { namespace google_breakpad {
@ -88,8 +88,8 @@ static void *Junk(void* data) {
TEST_F(MinidumpGeneratorTest, InProcess) { TEST_F(MinidumpGeneratorTest, InProcess) {
MinidumpGenerator generator; MinidumpGenerator generator;
string dump_filename = MinidumpGenerator::UniqueNameInDirectory(tempDir.path, string dump_filename =
NULL); MinidumpGenerator::UniqueNameInDirectory(tempDir.path(), NULL);
// Run an extra thread since MinidumpGenerator assumes there // Run an extra thread since MinidumpGenerator assumes there
// are 2 or more threads. // are 2 or more threads.
@ -179,8 +179,8 @@ TEST_F(MinidumpGeneratorTest, OutOfProcess) {
// Write a minidump of the child process. // Write a minidump of the child process.
MinidumpGenerator generator(child_task, MACH_PORT_NULL); MinidumpGenerator generator(child_task, MACH_PORT_NULL);
string dump_filename = MinidumpGenerator::UniqueNameInDirectory(tempDir.path, string dump_filename =
NULL); MinidumpGenerator::UniqueNameInDirectory(tempDir.path(), NULL);
ASSERT_TRUE(generator.Write(dump_filename.c_str())); ASSERT_TRUE(generator.Write(dump_filename.c_str()));
// Ensure that minidump file exists and is > 0 bytes. // Ensure that minidump file exists and is > 0 bytes.
@ -258,8 +258,8 @@ TEST_F(MinidumpGeneratorTest, CrossArchitectureDump) {
// Write a minidump of the child process. // Write a minidump of the child process.
MinidumpGenerator generator(child_task, MACH_PORT_NULL); MinidumpGenerator generator(child_task, MACH_PORT_NULL);
string dump_filename = MinidumpGenerator::UniqueNameInDirectory(tempDir.path, string dump_filename =
NULL); MinidumpGenerator::UniqueNameInDirectory(tempDir.path(), NULL);
ASSERT_TRUE(generator.Write(dump_filename.c_str())); ASSERT_TRUE(generator.Write(dump_filename.c_str()));
// Ensure that minidump file exists and is > 0 bytes. // Ensure that minidump file exists and is > 0 bytes.

12
src/common/linux/file_id_unittest.cc
View file

@ -35,6 +35,7 @@
#include "common/linux/file_id.h" #include "common/linux/file_id.h"
#include "common/linux/synth_elf.h" #include "common/linux/synth_elf.h"
#include "common/test_assembler.h" #include "common/test_assembler.h"
#include "common/tests/auto_tempdir.h"
#include "breakpad_googletest_includes.h" #include "breakpad_googletest_includes.h"
using namespace google_breakpad; using namespace google_breakpad;
@ -65,19 +66,19 @@ TEST(FileIDStripTest, StripSelf) {
exe_name[len] = '\0'; exe_name[len] = '\0';
// copy our binary to a temp file, and strip it // copy our binary to a temp file, and strip it
char templ[] = "/tmp/file-id-unittest-XXXXXX"; AutoTempDir temp_dir;
mktemp(templ); std::string templ = temp_dir.path() + "/file-id-unittest";
char cmdline[4096]; char cmdline[4096];
sprintf(cmdline, "cp \"%s\" \"%s\"", exe_name, templ); sprintf(cmdline, "cp \"%s\" \"%s\"", exe_name, templ.c_str());
ASSERT_EQ(system(cmdline), 0); ASSERT_EQ(system(cmdline), 0);
sprintf(cmdline, "strip \"%s\"", templ); sprintf(cmdline, "strip \"%s\"", templ.c_str());
ASSERT_EQ(system(cmdline), 0); ASSERT_EQ(system(cmdline), 0);
uint8_t identifier1[sizeof(MDGUID)]; uint8_t identifier1[sizeof(MDGUID)];
uint8_t identifier2[sizeof(MDGUID)]; uint8_t identifier2[sizeof(MDGUID)];
FileID fileid1(exe_name); FileID fileid1(exe_name);
EXPECT_TRUE(fileid1.ElfFileIdentifier(identifier1)); EXPECT_TRUE(fileid1.ElfFileIdentifier(identifier1));
FileID fileid2(templ); FileID fileid2(templ.c_str());
EXPECT_TRUE(fileid2.ElfFileIdentifier(identifier2)); EXPECT_TRUE(fileid2.ElfFileIdentifier(identifier2));
char identifier_string1[37]; char identifier_string1[37];
char identifier_string2[37]; char identifier_string2[37];
@ -86,7 +87,6 @@ TEST(FileIDStripTest, StripSelf) {
FileID::ConvertIdentifierToString(identifier2, identifier_string2, FileID::ConvertIdentifierToString(identifier2, identifier_string2,
37); 37);
EXPECT_STREQ(identifier_string1, identifier_string2); EXPECT_STREQ(identifier_string1, identifier_string2);
unlink(templ);
} }
class FileIDTest : public testing::Test { class FileIDTest : public testing::Test {

4
src/common/mac/macho_walker.cc
View file

@ -105,9 +105,11 @@ bool MachoWalker::WalkHeader(int cpu_type) {
bool MachoWalker::ReadBytes(void *buffer, size_t size, off_t offset) { bool MachoWalker::ReadBytes(void *buffer, size_t size, off_t offset) {
if (memory_) { if (memory_) {
if (offset < 0)
return false;
bool result = true; bool result = true;
if (offset + size > memory_size_) { if (offset + size > memory_size_) {
if (offset >= memory_size_) if (static_cast<size_t>(offset) >= memory_size_)
return false; return false;
size = memory_size_ - offset; size = memory_size_ - offset;
result = false; result = false;

52
src/client/mac/tests/auto_tempdir.h → src/common/tests/auto_tempdir.h
View file

@ -1,4 +1,4 @@
// Copyright (c) 2010, Google Inc. // Copyright (c) 2011, Google Inc.
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
@ -29,25 +29,42 @@
// Utility class for creating a temporary directory for unit tests // Utility class for creating a temporary directory for unit tests
// that is deleted in the destructor. // that is deleted in the destructor.
#ifndef GOOGLE_BREAKPAD_CLIENT_MAC_TESTS_AUTO_TEMPDIR #ifndef GOOGLE_BREAKPAD_COMMON_TESTS_AUTO_TEMPDIR
#define GOOGLE_BREAKPAD_CLIENT_MAC_TESTS_AUTO_TEMPDIR #define GOOGLE_BREAKPAD_COMMON_TESTS_AUTO_TEMPDIR
#include <dirent.h> #include <dirent.h>
#include <sys/types.h> #include <sys/types.h>
#include <string> #include <string>
#include "breakpad_googletest_includes.h"
#if !defined(__ANDROID__)
#define TEMPDIR "/tmp"
#else
#define TEMPDIR "/data/local/tmp"
#endif
namespace google_breakpad { namespace google_breakpad {
class AutoTempDir { class AutoTempDir {
public: public:
AutoTempDir() { AutoTempDir() {
char tempDir[16] = "/tmp/XXXXXXXXXX"; char temp_dir[] = TEMPDIR "/breakpad.XXXXXXXXXX";
mkdtemp(tempDir); EXPECT_TRUE(mkdtemp(temp_dir) != NULL);
path = tempDir; path_.assign(temp_dir);
} }
~AutoTempDir() { ~AutoTempDir() {
DeleteRecursively(path_);
}
const std::string& path() {
return path_;
}
private:
void DeleteRecursively(const std::string& path) {
// First remove any files in the dir // First remove any files in the dir
DIR* dir = opendir(path.c_str()); DIR* dir = opendir(path.c_str());
if (!dir) if (!dir)
@ -56,17 +73,26 @@ class AutoTempDir {
dirent* entry; dirent* entry;
while ((entry = readdir(dir)) != NULL) { while ((entry = readdir(dir)) != NULL) {
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
continue; continue;
std::string entryPath = path + "/" + entry->d_name; std::string entry_path = path + "/" + entry->d_name;
unlink(entryPath.c_str()); struct stat stats;
EXPECT_TRUE(lstat(entry_path.c_str(), &stats) == 0);
if (S_ISDIR(stats.st_mode))
DeleteRecursively(entry_path);
else
EXPECT_TRUE(unlink(entry_path.c_str()) == 0);
} }
closedir(dir); EXPECT_TRUE(closedir(dir) == 0);
rmdir(path.c_str()); EXPECT_TRUE(rmdir(path.c_str()) == 0);
} }
std::string path; // prevent copy construction and assignment
AutoTempDir(const AutoTempDir&);
AutoTempDir& operator=(const AutoTempDir&);
std::string path_;
}; };
} // namespace google_breakpad } // namespace google_breakpad
#endif // GOOGLE_BREAKPAD_CLIENT_MAC_TESTS_AUTO_TEMPDIR #endif // GOOGLE_BREAKPAD_COMMON_TESTS_AUTO_TEMPDIR