src/processor/minidump_processor_unittest.cc - fp2-dev/platform/external/google-breakpad - Gitiles

 // Copyright (c) 2006, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 // Unit test for MinidumpProcessor.  Uses a pre-generated minidump and
 // corresponding symbol file, and checks the stack frames for correctness.

 #include <stdlib.h>

 #include <string>
 #include <iostream>
 #include <fstream>
 #include <map>
 #include <utility>

 #include "breakpad_googletest_includes.h"
 #include "google_breakpad/processor/basic_source_line_resolver.h"
 #include "google_breakpad/processor/call_stack.h"
 #include "google_breakpad/processor/code_module.h"
 #include "google_breakpad/processor/code_modules.h"
 #include "google_breakpad/processor/minidump.h"
 #include "google_breakpad/processor/minidump_processor.h"
 #include "google_breakpad/processor/process_state.h"
 #include "google_breakpad/processor/stack_frame.h"
 #include "google_breakpad/processor/symbol_supplier.h"
 #include "processor/logging.h"
 #include "processor/scoped_ptr.h"

 using std::map;

 namespace google_breakpad {
 class MockMinidump : public Minidump {
  public:
   MockMinidump() : Minidump("") {
   }

   MOCK_METHOD0(Read, bool());
   MOCK_CONST_METHOD0(path, string());
   MOCK_CONST_METHOD0(header, const MDRawHeader*());
   MOCK_METHOD0(GetThreadList, MinidumpThreadList*());
 };
 }

 namespace {

 using google_breakpad::BasicSourceLineResolver;
 using google_breakpad::CallStack;
 using google_breakpad::CodeModule;
 using google_breakpad::MinidumpProcessor;
 using google_breakpad::MinidumpThreadList;
 using google_breakpad::MinidumpThread;
 using google_breakpad::MockMinidump;
 using google_breakpad::ProcessState;
 using google_breakpad::scoped_ptr;
 using google_breakpad::SymbolSupplier;
 using google_breakpad::SystemInfo;
 using std::string;
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::Ne;
 using ::testing::Property;
 using ::testing::Return;

 static const char *kSystemInfoOS = "Windows NT";
 static const char *kSystemInfoOSShort = "windows";
 static const char *kSystemInfoOSVersion = "5.1.2600 Service Pack 2";
 static const char *kSystemInfoCPU = "x86";
 static const char *kSystemInfoCPUInfo =
     "GenuineIntel family 6 model 13 stepping 8";

 #define ASSERT_TRUE_ABORT(cond) \
   if (!(cond)) {                                                        \
     fprintf(stderr, "FAILED: %s at %s:%d\n", #cond, __FILE__, __LINE__); \
     abort(); \
   }

 #define ASSERT_EQ_ABORT(e1, e2) ASSERT_TRUE_ABORT((e1) == (e2))

 class TestSymbolSupplier : public SymbolSupplier {
  public:
   TestSymbolSupplier() : interrupt_(false) {}

   virtual SymbolResult GetSymbolFile(const CodeModule *module,
                                      const SystemInfo *system_info,
                                      string *symbol_file);

   virtual SymbolResult GetSymbolFile(const CodeModule *module,
                                      const SystemInfo *system_info,
                                      string *symbol_file,
                                      string *symbol_data);

   virtual SymbolResult GetCStringSymbolData(const CodeModule *module,
                                             const SystemInfo *system_info,
                                             string *symbol_file,
                                             char **symbol_data);

   virtual void FreeSymbolData(const CodeModule *module);

   // When set to true, causes the SymbolSupplier to return INTERRUPT
   void set_interrupt(bool interrupt) { interrupt_ = interrupt; }

  private:
   bool interrupt_;
   map<string, char *> memory_buffers_;
 };

 SymbolSupplier::SymbolResult TestSymbolSupplier::GetSymbolFile(
     const CodeModule *module,
     const SystemInfo *system_info,
     string *symbol_file) {
   ASSERT_TRUE_ABORT(module);
   ASSERT_TRUE_ABORT(system_info);
   ASSERT_EQ_ABORT(system_info->cpu, kSystemInfoCPU);
   ASSERT_EQ_ABORT(system_info->cpu_info, kSystemInfoCPUInfo);
   ASSERT_EQ_ABORT(system_info->os, kSystemInfoOS);
   ASSERT_EQ_ABORT(system_info->os_short, kSystemInfoOSShort);
   ASSERT_EQ_ABORT(system_info->os_version, kSystemInfoOSVersion);

   if (interrupt_) {
     return INTERRUPT;
   }

   if (module && module->code_file() == "c:\\test_app.exe") {
       *symbol_file = string(getenv("srcdir") ? getenv("srcdir") : ".") +
                      "/src/processor/testdata/symbols/test_app.pdb/" +
                      module->debug_identifier() +
                      "/test_app.sym";
     return FOUND;
   }

   return NOT_FOUND;
 }

 SymbolSupplier::SymbolResult TestSymbolSupplier::GetSymbolFile(
     const CodeModule *module,
     const SystemInfo *system_info,
     string *symbol_file,
     string *symbol_data) {
   SymbolSupplier::SymbolResult s = GetSymbolFile(module, system_info,
                                                  symbol_file);
   if (s == FOUND) {
     std::ifstream in(symbol_file->c_str());
     std::getline(in, *symbol_data, std::string::traits_type::to_char_type(
                      std::string::traits_type::eof()));
     in.close();
   }

   return s;
 }

 SymbolSupplier::SymbolResult TestSymbolSupplier::GetCStringSymbolData(
     const CodeModule *module,
     const SystemInfo *system_info,
     string *symbol_file,
     char **symbol_data) {
   string symbol_data_string;
   SymbolSupplier::SymbolResult s = GetSymbolFile(module,
                                                  system_info,
                                                  symbol_file,
                                                  &symbol_data_string);
   if (s == FOUND) {
     unsigned int size = symbol_data_string.size() + 1;
     *symbol_data = new char[size];
     if (*symbol_data == NULL) {
       BPLOG(ERROR) << "Memory allocation failed for module: "
                    << module->code_file() << " size: " << size;
       return INTERRUPT;
     }
     strcpy(*symbol_data, symbol_data_string.c_str());
     memory_buffers_.insert(make_pair(module->code_file(), *symbol_data));
   }

   return s;
 }

 void TestSymbolSupplier::FreeSymbolData(const CodeModule *module) {
   map<string, char *>::iterator it = memory_buffers_.find(module->code_file());
   if (it != memory_buffers_.end()) {
     delete [] it->second;
     memory_buffers_.erase(it);
   }
 }

 // A mock symbol supplier that always returns NOT_FOUND; one current
 // use for testing the processor's caching of symbol lookups.
 class MockSymbolSupplier : public SymbolSupplier {
  public:
   MockSymbolSupplier() { }
   MOCK_METHOD3(GetSymbolFile, SymbolResult(const CodeModule*,
                                            const SystemInfo*,
                                            string*));
   MOCK_METHOD4(GetSymbolFile, SymbolResult(const CodeModule*,
                                            const SystemInfo*,
                                            string*,
                                            string*));
   MOCK_METHOD4(GetCStringSymbolData, SymbolResult(const CodeModule*,
                                                   const SystemInfo*,
                                                   string*,
                                                   char**));
   MOCK_METHOD1(FreeSymbolData, void(const CodeModule*));
 };

 class MinidumpProcessorTest : public ::testing::Test {
 };

 TEST_F(MinidumpProcessorTest, TestCorruptMinidumps) {
   MockMinidump dump;
   TestSymbolSupplier supplier;
   BasicSourceLineResolver resolver;
   MinidumpProcessor processor(&supplier, &resolver);
   ProcessState state;

   EXPECT_EQ(processor.Process("nonexistent minidump", &state),
             google_breakpad::PROCESS_ERROR_MINIDUMP_NOT_FOUND);

   EXPECT_CALL(dump, path()).WillRepeatedly(Return("mock minidump"));
   EXPECT_CALL(dump, Read()).WillRepeatedly(Return(true));

   MDRawHeader fakeHeader;
   fakeHeader.time_date_stamp = 0;
   EXPECT_CALL(dump, header()).WillOnce(Return((MDRawHeader*)NULL)).
       WillRepeatedly(Return(&fakeHeader));
   EXPECT_EQ(processor.Process(&dump, &state),
             google_breakpad::PROCESS_ERROR_NO_MINIDUMP_HEADER);

   EXPECT_CALL(dump, GetThreadList()).
       WillOnce(Return((MinidumpThreadList*)NULL));
   EXPECT_EQ(processor.Process(&dump, &state),
             google_breakpad::PROCESS_ERROR_NO_THREAD_LIST);
 }

 // This test case verifies that the symbol supplier is only consulted
 // once per minidump per module.
 TEST_F(MinidumpProcessorTest, TestSymbolSupplierLookupCounts) {
   MockSymbolSupplier supplier;
   BasicSourceLineResolver resolver;
   MinidumpProcessor processor(&supplier, &resolver);

   string minidump_file = string(getenv("srcdir") ? getenv("srcdir") : ".") +
                          "/src/processor/testdata/minidump2.dmp";
   ProcessState state;
   EXPECT_CALL(supplier, GetCStringSymbolData(
       Property(&google_breakpad::CodeModule::code_file,
                "c:\\test_app.exe"),
       _, _, _)).WillOnce(Return(SymbolSupplier::NOT_FOUND));
   EXPECT_CALL(supplier, GetCStringSymbolData(
       Property(&google_breakpad::CodeModule::code_file,
                Ne("c:\\test_app.exe")),
       _, _, _)).WillRepeatedly(Return(SymbolSupplier::NOT_FOUND));
   ASSERT_EQ(processor.Process(minidump_file, &state),
             google_breakpad::PROCESS_OK);

   ASSERT_TRUE(Mock::VerifyAndClearExpectations(&supplier));

   // We need to verify that across minidumps, the processor will refetch
   // symbol files, even with the same symbol supplier.
   EXPECT_CALL(supplier, GetCStringSymbolData(
       Property(&google_breakpad::CodeModule::code_file,
                "c:\\test_app.exe"),
       _, _, _)).WillOnce(Return(SymbolSupplier::NOT_FOUND));
   EXPECT_CALL(supplier, GetCStringSymbolData(
       Property(&google_breakpad::CodeModule::code_file,
                Ne("c:\\test_app.exe")),
       _, _, _)).WillRepeatedly(Return(SymbolSupplier::NOT_FOUND));
   ASSERT_EQ(processor.Process(minidump_file, &state),
             google_breakpad::PROCESS_OK);
 }

 TEST_F(MinidumpProcessorTest, TestBasicProcessing) {
   TestSymbolSupplier supplier;
   BasicSourceLineResolver resolver;
   MinidumpProcessor processor(&supplier, &resolver);

   string minidump_file = string(getenv("srcdir") ? getenv("srcdir") : ".") +
                          "/src/processor/testdata/minidump2.dmp";

   ProcessState state;
   ASSERT_EQ(processor.Process(minidump_file, &state),
             google_breakpad::PROCESS_OK);
   ASSERT_EQ(state.system_info()->os, kSystemInfoOS);
   ASSERT_EQ(state.system_info()->os_short, kSystemInfoOSShort);
   ASSERT_EQ(state.system_info()->os_version, kSystemInfoOSVersion);
   ASSERT_EQ(state.system_info()->cpu, kSystemInfoCPU);
   ASSERT_EQ(state.system_info()->cpu_info, kSystemInfoCPUInfo);
   ASSERT_TRUE(state.crashed());
   ASSERT_EQ(state.crash_reason(), "EXCEPTION_ACCESS_VIOLATION_WRITE");
   ASSERT_EQ(state.crash_address(), 0x45U);
   ASSERT_EQ(state.threads()->size(), size_t(1));
   ASSERT_EQ(state.requesting_thread(), 0);

   CallStack *stack = state.threads()->at(0);
   ASSERT_TRUE(stack);
   ASSERT_EQ(stack->frames()->size(), 4U);

   ASSERT_TRUE(stack->frames()->at(0)->module);
   ASSERT_EQ(stack->frames()->at(0)->module->base_address(), 0x400000U);
   ASSERT_EQ(stack->frames()->at(0)->module->code_file(), "c:\\test_app.exe");
   ASSERT_EQ(stack->frames()->at(0)->function_name,
             "`anonymous namespace'::CrashFunction");
   ASSERT_EQ(stack->frames()->at(0)->source_file_name, "c:\\test_app.cc");
   ASSERT_EQ(stack->frames()->at(0)->source_line, 58);

   ASSERT_TRUE(stack->frames()->at(1)->module);
   ASSERT_EQ(stack->frames()->at(1)->module->base_address(), 0x400000U);
   ASSERT_EQ(stack->frames()->at(1)->module->code_file(), "c:\\test_app.exe");
   ASSERT_EQ(stack->frames()->at(1)->function_name, "main");
   ASSERT_EQ(stack->frames()->at(1)->source_file_name, "c:\\test_app.cc");
   ASSERT_EQ(stack->frames()->at(1)->source_line, 65);

   // This comes from the CRT
   ASSERT_TRUE(stack->frames()->at(2)->module);
   ASSERT_EQ(stack->frames()->at(2)->module->base_address(), 0x400000U);
   ASSERT_EQ(stack->frames()->at(2)->module->code_file(), "c:\\test_app.exe");
   ASSERT_EQ(stack->frames()->at(2)->function_name, "__tmainCRTStartup");
   ASSERT_EQ(stack->frames()->at(2)->source_file_name,
             "f:\\sp\\vctools\\crt_bld\\self_x86\\crt\\src\\crt0.c");
   ASSERT_EQ(stack->frames()->at(2)->source_line, 327);

   // No debug info available for kernel32.dll
   ASSERT_TRUE(stack->frames()->at(3)->module);
   ASSERT_EQ(stack->frames()->at(3)->module->base_address(), 0x7c800000U);
   ASSERT_EQ(stack->frames()->at(3)->module->code_file(),
             "C:\\WINDOWS\\system32\\kernel32.dll");
   ASSERT_TRUE(stack->frames()->at(3)->function_name.empty());
   ASSERT_TRUE(stack->frames()->at(3)->source_file_name.empty());
   ASSERT_EQ(stack->frames()->at(3)->source_line, 0);

   ASSERT_EQ(state.modules()->module_count(), 13U);
   ASSERT_TRUE(state.modules()->GetMainModule());
   ASSERT_EQ(state.modules()->GetMainModule()->code_file(), "c:\\test_app.exe");
   ASSERT_FALSE(state.modules()->GetModuleForAddress(0));
   ASSERT_EQ(state.modules()->GetMainModule(),
             state.modules()->GetModuleForAddress(0x400000));
   ASSERT_EQ(state.modules()->GetModuleForAddress(0x7c801234)->debug_file(),
             "kernel32.pdb");
   ASSERT_EQ(state.modules()->GetModuleForAddress(0x77d43210)->version(),
             "5.1.2600.2622");

   // Test that disabled exploitability engine defaults to
   // EXPLOITABILITY_NOT_ANALYZED.
   ASSERT_EQ(google_breakpad::EXPLOITABILITY_NOT_ANALYZED,
             state.exploitability());

   // Test that the symbol supplier can interrupt processing
   state.Clear();
   supplier.set_interrupt(true);
   ASSERT_EQ(processor.Process(minidump_file, &state),
             google_breakpad::PROCESS_SYMBOL_SUPPLIER_INTERRUPTED);
 }
 }  // namespace

 int main(int argc, char *argv[]) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
	// Copyright (c) 2006, Google Inc.
	// All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are
	// met:
	//
	// * Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// * Redistributions in binary form must reproduce the above
	// copyright notice, this list of conditions and the following disclaimer
	// in the documentation and/or other materials provided with the
	// distribution.
	// * Neither the name of Google Inc. nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	// Unit test for MinidumpProcessor. Uses a pre-generated minidump and
	// corresponding symbol file, and checks the stack frames for correctness.

	#include <stdlib.h>

	#include <string>
	#include <iostream>
	#include <fstream>
	#include <map>
	#include <utility>

	#include "breakpad_googletest_includes.h"
	#include "google_breakpad/processor/basic_source_line_resolver.h"
	#include "google_breakpad/processor/call_stack.h"
	#include "google_breakpad/processor/code_module.h"
	#include "google_breakpad/processor/code_modules.h"
	#include "google_breakpad/processor/minidump.h"
	#include "google_breakpad/processor/minidump_processor.h"
	#include "google_breakpad/processor/process_state.h"
	#include "google_breakpad/processor/stack_frame.h"
	#include "google_breakpad/processor/symbol_supplier.h"
	#include "processor/logging.h"
	#include "processor/scoped_ptr.h"

	using std::map;

	namespace google_breakpad {
	class MockMinidump : public Minidump {
	public:
	MockMinidump() : Minidump("") {
	}

	MOCK_METHOD0(Read, bool());
	MOCK_CONST_METHOD0(path, string());
	MOCK_CONST_METHOD0(header, const MDRawHeader*());
	MOCK_METHOD0(GetThreadList, MinidumpThreadList*());
	};
	}

	namespace {

	using google_breakpad::BasicSourceLineResolver;
	using google_breakpad::CallStack;
	using google_breakpad::CodeModule;
	using google_breakpad::MinidumpProcessor;
	using google_breakpad::MinidumpThreadList;
	using google_breakpad::MinidumpThread;
	using google_breakpad::MockMinidump;
	using google_breakpad::ProcessState;
	using google_breakpad::scoped_ptr;
	using google_breakpad::SymbolSupplier;
	using google_breakpad::SystemInfo;
	using std::string;
	using ::testing::_;
	using ::testing::Mock;
	using ::testing::Ne;
	using ::testing::Property;
	using ::testing::Return;

	static const char *kSystemInfoOS = "Windows NT";
	static const char *kSystemInfoOSShort = "windows";
	static const char *kSystemInfoOSVersion = "5.1.2600 Service Pack 2";
	static const char *kSystemInfoCPU = "x86";
	static const char *kSystemInfoCPUInfo =
	"GenuineIntel family 6 model 13 stepping 8";

	#define ASSERT_TRUE_ABORT(cond) \
	if (!(cond)) { \
	fprintf(stderr, "FAILED: %s at %s:%d\n", #cond, __FILE__, __LINE__); \
	abort(); \
	}

	#define ASSERT_EQ_ABORT(e1, e2) ASSERT_TRUE_ABORT((e1) == (e2))

	class TestSymbolSupplier : public SymbolSupplier {
	public:
	TestSymbolSupplier() : interrupt_(false) {}

	virtual SymbolResult GetSymbolFile(const CodeModule *module,
	const SystemInfo *system_info,
	string *symbol_file);

	virtual SymbolResult GetSymbolFile(const CodeModule *module,
	const SystemInfo *system_info,
	string *symbol_file,
	string *symbol_data);

	virtual SymbolResult GetCStringSymbolData(const CodeModule *module,
	const SystemInfo *system_info,
	string *symbol_file,
	char **symbol_data);

	virtual void FreeSymbolData(const CodeModule *module);

	// When set to true, causes the SymbolSupplier to return INTERRUPT
	void set_interrupt(bool interrupt) { interrupt_ = interrupt; }

	private:
	bool interrupt_;
	map<string, char *> memory_buffers_;
	};

	SymbolSupplier::SymbolResult TestSymbolSupplier::GetSymbolFile(
	const CodeModule *module,
	const SystemInfo *system_info,
	string *symbol_file) {
	ASSERT_TRUE_ABORT(module);
	ASSERT_TRUE_ABORT(system_info);
	ASSERT_EQ_ABORT(system_info->cpu, kSystemInfoCPU);
	ASSERT_EQ_ABORT(system_info->cpu_info, kSystemInfoCPUInfo);
	ASSERT_EQ_ABORT(system_info->os, kSystemInfoOS);
	ASSERT_EQ_ABORT(system_info->os_short, kSystemInfoOSShort);
	ASSERT_EQ_ABORT(system_info->os_version, kSystemInfoOSVersion);

	if (interrupt_) {
	return INTERRUPT;
	}

	if (module && module->code_file() == "c:\\test_app.exe") {
	*symbol_file = string(getenv("srcdir") ? getenv("srcdir") : ".") +
	"/src/processor/testdata/symbols/test_app.pdb/" +
	module->debug_identifier() +
	"/test_app.sym";
	return FOUND;
	}

	return NOT_FOUND;
	}

	SymbolSupplier::SymbolResult TestSymbolSupplier::GetSymbolFile(
	const CodeModule *module,
	const SystemInfo *system_info,
	string *symbol_file,
	string *symbol_data) {
	SymbolSupplier::SymbolResult s = GetSymbolFile(module, system_info,
	symbol_file);
	if (s == FOUND) {
	std::ifstream in(symbol_file->c_str());
	std::getline(in, *symbol_data, std::string::traits_type::to_char_type(
	std::string::traits_type::eof()));
	in.close();
	}

	return s;
	}

	SymbolSupplier::SymbolResult TestSymbolSupplier::GetCStringSymbolData(
	const CodeModule *module,
	const SystemInfo *system_info,
	string *symbol_file,
	char **symbol_data) {
	string symbol_data_string;
	SymbolSupplier::SymbolResult s = GetSymbolFile(module,
	system_info,
	symbol_file,
	&symbol_data_string);
	if (s == FOUND) {
	unsigned int size = symbol_data_string.size() + 1;
	*symbol_data = new char[size];
	if (*symbol_data == NULL) {
	BPLOG(ERROR) << "Memory allocation failed for module: "
	<< module->code_file() << " size: " << size;
	return INTERRUPT;
	}
	strcpy(*symbol_data, symbol_data_string.c_str());
	memory_buffers_.insert(make_pair(module->code_file(), *symbol_data));
	}

	return s;
	}

	void TestSymbolSupplier::FreeSymbolData(const CodeModule *module) {
	map<string, char *>::iterator it = memory_buffers_.find(module->code_file());
	if (it != memory_buffers_.end()) {
	delete [] it->second;
	memory_buffers_.erase(it);
	}
	}

	// A mock symbol supplier that always returns NOT_FOUND; one current
	// use for testing the processor's caching of symbol lookups.
	class MockSymbolSupplier : public SymbolSupplier {
	public:
	MockSymbolSupplier() { }
	MOCK_METHOD3(GetSymbolFile, SymbolResult(const CodeModule*,
	const SystemInfo*,
	string*));
	MOCK_METHOD4(GetSymbolFile, SymbolResult(const CodeModule*,
	const SystemInfo*,
	string*,
	string*));
	MOCK_METHOD4(GetCStringSymbolData, SymbolResult(const CodeModule*,
	const SystemInfo*,
	string*,
	char**));
	MOCK_METHOD1(FreeSymbolData, void(const CodeModule*));
	};

	class MinidumpProcessorTest : public ::testing::Test {
	};

	TEST_F(MinidumpProcessorTest, TestCorruptMinidumps) {
	MockMinidump dump;
	TestSymbolSupplier supplier;
	BasicSourceLineResolver resolver;
	MinidumpProcessor processor(&supplier, &resolver);
	ProcessState state;

	EXPECT_EQ(processor.Process("nonexistent minidump", &state),
	google_breakpad::PROCESS_ERROR_MINIDUMP_NOT_FOUND);

	EXPECT_CALL(dump, path()).WillRepeatedly(Return("mock minidump"));
	EXPECT_CALL(dump, Read()).WillRepeatedly(Return(true));

	MDRawHeader fakeHeader;
	fakeHeader.time_date_stamp = 0;
	EXPECT_CALL(dump, header()).WillOnce(Return((MDRawHeader*)NULL)).
	WillRepeatedly(Return(&fakeHeader));
	EXPECT_EQ(processor.Process(&dump, &state),
	google_breakpad::PROCESS_ERROR_NO_MINIDUMP_HEADER);

	EXPECT_CALL(dump, GetThreadList()).
	WillOnce(Return((MinidumpThreadList*)NULL));
	EXPECT_EQ(processor.Process(&dump, &state),
	google_breakpad::PROCESS_ERROR_NO_THREAD_LIST);
	}

	// This test case verifies that the symbol supplier is only consulted
	// once per minidump per module.
	TEST_F(MinidumpProcessorTest, TestSymbolSupplierLookupCounts) {
	MockSymbolSupplier supplier;
	BasicSourceLineResolver resolver;
	MinidumpProcessor processor(&supplier, &resolver);

	string minidump_file = string(getenv("srcdir") ? getenv("srcdir") : ".") +
	"/src/processor/testdata/minidump2.dmp";
	ProcessState state;
	EXPECT_CALL(supplier, GetCStringSymbolData(
	Property(&google_breakpad::CodeModule::code_file,
	"c:\\test_app.exe"),
	_, _, _)).WillOnce(Return(SymbolSupplier::NOT_FOUND));
	EXPECT_CALL(supplier, GetCStringSymbolData(
	Property(&google_breakpad::CodeModule::code_file,
	Ne("c:\\test_app.exe")),
	_, _, _)).WillRepeatedly(Return(SymbolSupplier::NOT_FOUND));
	ASSERT_EQ(processor.Process(minidump_file, &state),
	google_breakpad::PROCESS_OK);

	ASSERT_TRUE(Mock::VerifyAndClearExpectations(&supplier));

	// We need to verify that across minidumps, the processor will refetch
	// symbol files, even with the same symbol supplier.
	EXPECT_CALL(supplier, GetCStringSymbolData(
	Property(&google_breakpad::CodeModule::code_file,
	"c:\\test_app.exe"),
	_, _, _)).WillOnce(Return(SymbolSupplier::NOT_FOUND));
	EXPECT_CALL(supplier, GetCStringSymbolData(
	Property(&google_breakpad::CodeModule::code_file,
	Ne("c:\\test_app.exe")),
	_, _, _)).WillRepeatedly(Return(SymbolSupplier::NOT_FOUND));
	ASSERT_EQ(processor.Process(minidump_file, &state),
	google_breakpad::PROCESS_OK);
	}

	TEST_F(MinidumpProcessorTest, TestBasicProcessing) {
	TestSymbolSupplier supplier;
	BasicSourceLineResolver resolver;
	MinidumpProcessor processor(&supplier, &resolver);

	string minidump_file = string(getenv("srcdir") ? getenv("srcdir") : ".") +
	"/src/processor/testdata/minidump2.dmp";

	ProcessState state;
	ASSERT_EQ(processor.Process(minidump_file, &state),
	google_breakpad::PROCESS_OK);
	ASSERT_EQ(state.system_info()->os, kSystemInfoOS);
	ASSERT_EQ(state.system_info()->os_short, kSystemInfoOSShort);
	ASSERT_EQ(state.system_info()->os_version, kSystemInfoOSVersion);
	ASSERT_EQ(state.system_info()->cpu, kSystemInfoCPU);
	ASSERT_EQ(state.system_info()->cpu_info, kSystemInfoCPUInfo);
	ASSERT_TRUE(state.crashed());
	ASSERT_EQ(state.crash_reason(), "EXCEPTION_ACCESS_VIOLATION_WRITE");
	ASSERT_EQ(state.crash_address(), 0x45U);
	ASSERT_EQ(state.threads()->size(), size_t(1));
	ASSERT_EQ(state.requesting_thread(), 0);

	CallStack *stack = state.threads()->at(0);
	ASSERT_TRUE(stack);
	ASSERT_EQ(stack->frames()->size(), 4U);

	ASSERT_TRUE(stack->frames()->at(0)->module);
	ASSERT_EQ(stack->frames()->at(0)->module->base_address(), 0x400000U);
	ASSERT_EQ(stack->frames()->at(0)->module->code_file(), "c:\\test_app.exe");
	ASSERT_EQ(stack->frames()->at(0)->function_name,
	"`anonymous namespace'::CrashFunction");
	ASSERT_EQ(stack->frames()->at(0)->source_file_name, "c:\\test_app.cc");
	ASSERT_EQ(stack->frames()->at(0)->source_line, 58);

	ASSERT_TRUE(stack->frames()->at(1)->module);
	ASSERT_EQ(stack->frames()->at(1)->module->base_address(), 0x400000U);
	ASSERT_EQ(stack->frames()->at(1)->module->code_file(), "c:\\test_app.exe");
	ASSERT_EQ(stack->frames()->at(1)->function_name, "main");
	ASSERT_EQ(stack->frames()->at(1)->source_file_name, "c:\\test_app.cc");
	ASSERT_EQ(stack->frames()->at(1)->source_line, 65);

	// This comes from the CRT
	ASSERT_TRUE(stack->frames()->at(2)->module);
	ASSERT_EQ(stack->frames()->at(2)->module->base_address(), 0x400000U);
	ASSERT_EQ(stack->frames()->at(2)->module->code_file(), "c:\\test_app.exe");
	ASSERT_EQ(stack->frames()->at(2)->function_name, "__tmainCRTStartup");
	ASSERT_EQ(stack->frames()->at(2)->source_file_name,
	"f:\\sp\\vctools\\crt_bld\\self_x86\\crt\\src\\crt0.c");
	ASSERT_EQ(stack->frames()->at(2)->source_line, 327);

	// No debug info available for kernel32.dll
	ASSERT_TRUE(stack->frames()->at(3)->module);
	ASSERT_EQ(stack->frames()->at(3)->module->base_address(), 0x7c800000U);
	ASSERT_EQ(stack->frames()->at(3)->module->code_file(),
	"C:\\WINDOWS\\system32\\kernel32.dll");
	ASSERT_TRUE(stack->frames()->at(3)->function_name.empty());
	ASSERT_TRUE(stack->frames()->at(3)->source_file_name.empty());
	ASSERT_EQ(stack->frames()->at(3)->source_line, 0);

	ASSERT_EQ(state.modules()->module_count(), 13U);
	ASSERT_TRUE(state.modules()->GetMainModule());
	ASSERT_EQ(state.modules()->GetMainModule()->code_file(), "c:\\test_app.exe");
	ASSERT_FALSE(state.modules()->GetModuleForAddress(0));
	ASSERT_EQ(state.modules()->GetMainModule(),
	state.modules()->GetModuleForAddress(0x400000));
	ASSERT_EQ(state.modules()->GetModuleForAddress(0x7c801234)->debug_file(),
	"kernel32.pdb");
	ASSERT_EQ(state.modules()->GetModuleForAddress(0x77d43210)->version(),
	"5.1.2600.2622");

	// Test that disabled exploitability engine defaults to
	// EXPLOITABILITY_NOT_ANALYZED.
	ASSERT_EQ(google_breakpad::EXPLOITABILITY_NOT_ANALYZED,
	state.exploitability());

	// Test that the symbol supplier can interrupt processing
	state.Clear();
	supplier.set_interrupt(true);
	ASSERT_EQ(processor.Process(minidump_file, &state),
	google_breakpad::PROCESS_SYMBOL_SUPPLIER_INTERRUPTED);
	}
	} // namespace

	int main(int argc, char *argv[]) {
	::testing::InitGoogleTest(&argc, argv);
	return RUN_ALL_TESTS();
	}