src/processor/stackwalker_unittest_utils.h - platform/external/google-breakpad - Git at Google


            
            // -*- mode: C++ -*-


            // Copyright (c) 2010, 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.


            // Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>


            // Mock classes for writing stackwalker tests, shared amongst architectures.


            #ifndef PROCESSOR_STACKWALKER_UNITTEST_UTILS_H_

            
            #define PROCESSOR_STACKWALKER_UNITTEST_UTILS_H_


            #include <assert.h>

            
            #include <stdlib.h>

            
            #include <string>

            
            #include <vector>


            #include "common/using_std_string.h"

            
            #include "google_breakpad/common/breakpad_types.h"

            
            #include "google_breakpad/processor/code_module.h"

            
            #include "google_breakpad/processor/code_modules.h"

            
            #include "google_breakpad/processor/memory_region.h"

            
            #include "google_breakpad/processor/symbol_supplier.h"

            
            #include "google_breakpad/processor/system_info.h"

            
            #include "processor/linked_ptr.h"


            class MockMemoryRegion: public google_breakpad::MemoryRegion {

            
             public:

            
              MockMemoryRegion(): base_address_(0) { }


              // Set this region's address and contents. If we have placed an

            
              // instance of this class in a test fixture class, individual tests

            
              // can use this to provide the region's contents.

            
              void Init(uint64_t base_address, const string& contents) {

            
                base_address_ = base_address;

            
                contents_ = contents;

            
              }


              uint64_t GetBase() const { return base_address_; }

            
              uint32_t GetSize() const { return contents_.size(); }


              bool GetMemoryAtAddress(uint64_t address, uint8_t*  value) const {

            
                return GetMemoryLittleEndian(address, value);

            
              }

            
              bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const {

            
                return GetMemoryLittleEndian(address, value);

            
              }

            
              bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const {

            
                return GetMemoryLittleEndian(address, value);

            
              }

            
              bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const {

            
                return GetMemoryLittleEndian(address, value);

            
              }

            
              void Print() const {

            
                assert(false);

            
              }


             private:

            
              // Fetch a little-endian value from ADDRESS in contents_ whose size

            
              // is BYTES, and store it in *VALUE. Return true on success.

            
              template<typename ValueType>

            
              bool GetMemoryLittleEndian(uint64_t address, ValueType* value) const {

            
                if (address < base_address_ ||

            
                    address - base_address_ + sizeof(ValueType) > contents_.size())

            
                  return false;

            
                ValueType v = 0;

            
                int start = address - base_address_;

            
                // The loop condition is odd, but it's correct for size_t.

            
                for (size_t i = sizeof(ValueType) - 1; i < sizeof(ValueType); i--)

            
                  v = (v << 8) | static_cast<unsigned char>(contents_[start + i]);

            
                *value = v;

            
                return true;

            
              }


              uint64_t base_address_;

            
              string contents_;

            
            };


            class MockCodeModule: public google_breakpad::CodeModule {

            
             public:

            
              MockCodeModule(uint64_t base_address, uint64_t size,

            
                             const string& code_file, const string& version)

            
                  : base_address_(base_address), size_(size), code_file_(code_file) { }


              uint64_t base_address()       const { return base_address_; }

            
              uint64_t size()               const { return size_; }

            
              string code_file()        const { return code_file_; }

            
              string code_identifier()  const { return code_file_; }

            
              string debug_file()       const { return code_file_; }

            
              string debug_identifier() const { return code_file_; }

            
              string version()          const { return version_; }

            
              google_breakpad::CodeModule* Copy() const {

            
                abort(); // Tests won't use this.

            
              }

            
              virtual bool is_unloaded() const { return false; }

            
              virtual uint64_t shrink_down_delta() const { return 0; }

            
              virtual void SetShrinkDownDelta(uint64_t shrink_down_delta) {}


             private:

            
              uint64_t base_address_;

            
              uint64_t size_;

            
              string code_file_;

            
              string version_;

            
            };


            class MockCodeModules: public google_breakpad::CodeModules {

            
             public:

            
              typedef google_breakpad::CodeModule CodeModule;

            
              typedef google_breakpad::CodeModules CodeModules;


              void Add(const MockCodeModule* module) {

            
                modules_.push_back(module);

            
              }


              unsigned int module_count() const { return modules_.size(); }


              const CodeModule* GetModuleForAddress(uint64_t address) const {

            
                for (ModuleVector::const_iterator i = modules_.begin();

            
                     i != modules_.end(); i++) {

            
                  const MockCodeModule* module = *i;

            
                  if (module->base_address() <= address &&

            
                      address - module->base_address() < module->size())

            
                    return module;

            
                }

            
                return NULL;

            
              };


              const CodeModule* GetMainModule() const { return modules_[0]; }


              const CodeModule* GetModuleAtSequence(unsigned int sequence) const {

            
                return modules_.at(sequence);

            
              }


              const CodeModule* GetModuleAtIndex(unsigned int index) const {

            
                return modules_.at(index);

            
              }


              CodeModules* Copy() const { abort(); }  // Tests won't use this


              virtual std::vector<google_breakpad::linked_ptr<const CodeModule> >

            
              GetShrunkRangeModules() const {

            
                return std::vector<google_breakpad::linked_ptr<const CodeModule> >();

            
              }


             private:

            
              typedef std::vector<const MockCodeModule*> ModuleVector;

            
              ModuleVector modules_;

            
            };


            class MockSymbolSupplier: public google_breakpad::SymbolSupplier {

            
             public:

            
              typedef google_breakpad::CodeModule CodeModule;

            
              typedef google_breakpad::SystemInfo SystemInfo;

            
              MOCK_METHOD3(GetSymbolFile, SymbolResult(const CodeModule* module,

            
                                                       const SystemInfo* system_info,

            
                                                       string* symbol_file));

            
              MOCK_METHOD4(GetSymbolFile, SymbolResult(const CodeModule* module,

            
                                                       const SystemInfo* system_info,

            
                                                       string* symbol_file,

            
                                                       string* symbol_data));

            
              MOCK_METHOD5(GetCStringSymbolData, SymbolResult(const CodeModule* module,

            
                                                              const SystemInfo* system_info,

            
                                                              string* symbol_file,

            
                                                              char** symbol_data,

            
                                                              size_t* symbol_data_size));

            
              MOCK_METHOD1(FreeSymbolData, void(const CodeModule* module));


              // Copies the passed string contents into a newly allocated buffer.

            
              // The newly allocated buffer will be freed during destruction.

            
              char* CopySymbolDataAndOwnTheCopy(const string& info,

            
                                                size_t* symbol_data_size) {

            
                *symbol_data_size = info.size() + 1;

            
                char* symbol_data = new char[*symbol_data_size];

            
                memcpy(symbol_data, info.c_str(), info.size());

            
                symbol_data[info.size()] = '\0';

            
                symbol_data_to_free_.push_back(symbol_data);

            
                return symbol_data;

            
              }


              virtual ~MockSymbolSupplier() {

            
                for (SymbolDataVector::const_iterator i = symbol_data_to_free_.begin();

            
                     i != symbol_data_to_free_.end(); i++) {

            
                  char* symbol_data = *i;

            
                  delete [] symbol_data;

            
                }

            
              }


             private:

            
              // List of symbol data to be freed upon destruction

            
              typedef std::vector<char*> SymbolDataVector;

            
              SymbolDataVector symbol_data_to_free_;

            
            };


            #endif // PROCESSOR_STACKWALKER_UNITTEST_UTILS_H_
	// -- mode: C++ --

	// Copyright (c) 2010, 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.

	// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>

	// Mock classes for writing stackwalker tests, shared amongst architectures.

	#ifndef PROCESSOR_STACKWALKER_UNITTEST_UTILS_H_
	#define PROCESSOR_STACKWALKER_UNITTEST_UTILS_H_

	#include <assert.h>
	#include <stdlib.h>
	#include <string>
	#include <vector>

	#include "common/using_std_string.h"
	#include "google_breakpad/common/breakpad_types.h"
	#include "google_breakpad/processor/code_module.h"
	#include "google_breakpad/processor/code_modules.h"
	#include "google_breakpad/processor/memory_region.h"
	#include "google_breakpad/processor/symbol_supplier.h"
	#include "google_breakpad/processor/system_info.h"
	#include "processor/linked_ptr.h"

	class MockMemoryRegion: public google_breakpad::MemoryRegion {
	public:
	MockMemoryRegion(): base_address_(0) { }

	// Set this region's address and contents. If we have placed an
	// instance of this class in a test fixture class, individual tests
	// can use this to provide the region's contents.
	void Init(uint64_t base_address, const string& contents) {
	base_address_ = base_address;
	contents_ = contents;
	}

	uint64_t GetBase() const { return base_address_; }
	uint32_t GetSize() const { return contents_.size(); }

	bool GetMemoryAtAddress(uint64_t address, uint8_t* value) const {
	return GetMemoryLittleEndian(address, value);
	}
	bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const {
	return GetMemoryLittleEndian(address, value);
	}
	bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const {
	return GetMemoryLittleEndian(address, value);
	}
	bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const {
	return GetMemoryLittleEndian(address, value);
	}
	void Print() const {
	assert(false);
	}

	private:
	// Fetch a little-endian value from ADDRESS in contents_ whose size
	// is BYTES, and store it in *VALUE. Return true on success.
	template<typename ValueType>
	bool GetMemoryLittleEndian(uint64_t address, ValueType* value) const {
	if (address < base_address_ \|\|
	address - base_address_ + sizeof(ValueType) > contents_.size())
	return false;
	ValueType v = 0;
	int start = address - base_address_;
	// The loop condition is odd, but it's correct for size_t.
	for (size_t i = sizeof(ValueType) - 1; i < sizeof(ValueType); i--)
	v = (v << 8) \| static_cast<unsigned char>(contents_[start + i]);
	*value = v;
	return true;
	}

	uint64_t base_address_;
	string contents_;
	};

	class MockCodeModule: public google_breakpad::CodeModule {
	public:
	MockCodeModule(uint64_t base_address, uint64_t size,
	const string& code_file, const string& version)
	: base_address_(base_address), size_(size), code_file_(code_file) { }

	uint64_t base_address() const { return base_address_; }
	uint64_t size() const { return size_; }
	string code_file() const { return code_file_; }
	string code_identifier() const { return code_file_; }
	string debug_file() const { return code_file_; }
	string debug_identifier() const { return code_file_; }
	string version() const { return version_; }
	google_breakpad::CodeModule* Copy() const {
	abort(); // Tests won't use this.
	}
	virtual bool is_unloaded() const { return false; }
	virtual uint64_t shrink_down_delta() const { return 0; }
	virtual void SetShrinkDownDelta(uint64_t shrink_down_delta) {}

	private:
	uint64_t base_address_;
	uint64_t size_;
	string code_file_;
	string version_;
	};

	class MockCodeModules: public google_breakpad::CodeModules {
	public:
	typedef google_breakpad::CodeModule CodeModule;
	typedef google_breakpad::CodeModules CodeModules;

	void Add(const MockCodeModule* module) {
	modules_.push_back(module);
	}

	unsigned int module_count() const { return modules_.size(); }

	const CodeModule* GetModuleForAddress(uint64_t address) const {
	for (ModuleVector::const_iterator i = modules_.begin();
	i != modules_.end(); i++) {
	const MockCodeModule* module = *i;
	if (module->base_address() <= address &&
	address - module->base_address() < module->size())
	return module;
	}
	return NULL;
	};

	const CodeModule* GetMainModule() const { return modules_[0]; }

	const CodeModule* GetModuleAtSequence(unsigned int sequence) const {
	return modules_.at(sequence);
	}

	const CodeModule* GetModuleAtIndex(unsigned int index) const {
	return modules_.at(index);
	}

	CodeModules* Copy() const { abort(); } // Tests won't use this

	virtual std::vector<google_breakpad::linked_ptr<const CodeModule> >
	GetShrunkRangeModules() const {
	return std::vector<google_breakpad::linked_ptr<const CodeModule> >();
	}

	private:
	typedef std::vector<const MockCodeModule*> ModuleVector;
	ModuleVector modules_;
	};

	class MockSymbolSupplier: public google_breakpad::SymbolSupplier {
	public:
	typedef google_breakpad::CodeModule CodeModule;
	typedef google_breakpad::SystemInfo SystemInfo;
	MOCK_METHOD3(GetSymbolFile, SymbolResult(const CodeModule* module,
	const SystemInfo* system_info,
	string* symbol_file));
	MOCK_METHOD4(GetSymbolFile, SymbolResult(const CodeModule* module,
	const SystemInfo* system_info,
	string* symbol_file,
	string* symbol_data));
	MOCK_METHOD5(GetCStringSymbolData, SymbolResult(const CodeModule* module,
	const SystemInfo* system_info,
	string* symbol_file,
	char** symbol_data,
	size_t* symbol_data_size));
	MOCK_METHOD1(FreeSymbolData, void(const CodeModule* module));

	// Copies the passed string contents into a newly allocated buffer.
	// The newly allocated buffer will be freed during destruction.
	char* CopySymbolDataAndOwnTheCopy(const string& info,
	size_t* symbol_data_size) {
	*symbol_data_size = info.size() + 1;
	char* symbol_data = new char[*symbol_data_size];
	memcpy(symbol_data, info.c_str(), info.size());
	symbol_data[info.size()] = '\0';
	symbol_data_to_free_.push_back(symbol_data);
	return symbol_data;
	}

	virtual ~MockSymbolSupplier() {
	for (SymbolDataVector::const_iterator i = symbol_data_to_free_.begin();
	i != symbol_data_to_free_.end(); i++) {
	char* symbol_data = *i;
	delete [] symbol_data;
	}
	}

	private:
	// List of symbol data to be freed upon destruction
	typedef std::vector<char*> SymbolDataVector;
	SymbolDataVector symbol_data_to_free_;
	};

	#endif // PROCESSOR_STACKWALKER_UNITTEST_UTILS_H_