Breakpad Processor: Add new unit tests for google_breakpad::Minidump

src/processor/synth_minidump.h

Index: src/processor/synth_minidump.h
===================================================================
new file mode 100644
--- /dev/null
+++ b/src/processor/synth_minidump.h
@@ -0,0 +1,357 @@
+// -*- 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>
+
+// synth_minidump.h: Interface to SynthMinidump: fake minidump generator.
+//
+// We treat a minidump file as the concatenation of a bunch of
+// TestAssembler::Sections. The file header, stream directory,
+// streams, memory regions, strings, and so on --- each is a Section
+// that eventually gets appended to the minidump. Dump, Memory,
+// Context, Thread, and so on all inherit from TestAssembler::Section.
+// For example:
+//
+//    using google_breakpad::TestAssembler::kLittleEndian;
+//    using google_breakpad::SynthMinidump::Context;
+//    using google_breakpad::SynthMinidump::Dump;
+//    using google_breakpad::SynthMinidump::Memory;
+//    using google_breakpad::SynthMinidump::Thread;
+//    
+//    Dump minidump(MD_NORMAL, kLittleEndian);
+//    
+//    Memory stack1(minidump, 0x569eb0a9);
+//    ... build contents of stack1 with TestAssembler::Section functions ...
+//    
+//    MDRawContextX86 x86_context1;
+//    x86_context1.context_flags = MD_CONTEXT_X86;
+//    x86_context1.eip = 0x7c90eb94;
+//    x86_context1.esp = 0x569eb0a9;
+//    x86_context1.ebp = x86_context1.esp + something appropriate;
+//    Context context1(minidump, x86_context1);
+//    
+//    Thread thread1(minidump, 0xe4a4821d, stack1, context1);
+//    
+//    minidump.Add(&stack1);
+//    minidump.Add(&context1);
+//    minidump.Add(&thread1);
+//    minidump.Finish();
+//    
+//    string contents;
+//    EXPECT_TRUE(minidump.GetContents(&contents));
+//    // contents now holds the bytes of a minidump file
+//
+// Because the TestAssembler classes let us write Label references to
+// sections before the Labels' values are known, this gives us
+// flexibility in how we put the dump together: minidump pieces can
+// hold the file offsets of other minidump pieces before the
+// referents' positions have been decided. As long as everything has
+// been placed by the time we call dump.GetContents to obtain the
+// bytes, all the Labels' values will be known, and everything will
+// get patched up appropriately.
+//   
+// The dump.Add(thing) functions append THINGS's contents to the
+// minidump, but they also do two other things:
+//
+// - dump.Add(thing) invokes thing->Finish, which tells *thing the
+//   offset within the file at which it was placed, and allows *thing
+//   to do any final content generation.
+//
+// - If THING is something which should receive an entry in some sort
+//   of list or directory, then dump.Add(THING) automatically creates
+//   the appropriate directory or list entry. Streams must appear in
+//   the stream directory; memory ranges should be listed in the
+//   memory list; threads should be placed in the thread list; and so
+//   on.
+//
+// By convention, Section subclass constructors that take references
+// to other Sections do not take care of 'Add'ing their arguments to
+// the dump. For example, although the Thread constructor takes
+// references to a Memory and a Context, it does not add them to the
+// dump on the caller's behalf. Rather, the caller is responsible for
+// 'Add'ing every section they create. This allows Sections to be
+// cited from more than one place; for example, Memory ranges are
+// cited both from Thread objects (as their stack contents) and by the
+// memory list stream.
+//
+// If you forget to Add some Section, the Dump::GetContents call will
+// fail, as the TestAssembler::Labels used to cite the Section's
+// contents from elsewhere will still be undefined.
+#ifndef PROCESSOR_SYNTH_MINIDUMP_H__
+#define PROCESSOR_SYNTH_MINIDUMP_H__
+
+#include <cassert>
+#include <iostream>
+#include <string>
+
+#include "google_breakpad/common/breakpad_types.h"
+#include "google_breakpad/common/minidump_format.h"
+#include "processor/test_assembler.h"
+
+namespace google_breakpad {
+
+namespace SynthMinidump {
+
+using std::string;
+using TestAssembler::Endianness;
+using TestAssembler::kBigEndian;
+using TestAssembler::kLittleEndian;
+using TestAssembler::kUnsetEndian;
+using TestAssembler::Label;
+
+class Dump;
+class Memory;
+class String;
+
+// A TestAssembler::Section which will be appended to a minidump.
+class Section: public TestAssembler::Section {
+ public:
+  explicit Section(const Dump &dump);
+
+  // Append an MDLocationDescriptor referring to this section to SECTION.
+  // If 'this' is NULL, append a descriptor with a zero length and MDRVA.
+  //
+  // (I couldn't find the language in the C++ standard that says that
+  // invoking member functions of a NULL pointer to a class type is
+  // bad, if such language exists. Having this function handle NULL
+  // 'this' is convenient, but if it causes trouble, it's not hard to
+  // do differently.)
+  void CiteLocationIn(TestAssembler::Section *section) const;
+
+  // Note that this section's contents are complete, and that it has
+  // been placed in the minidump file at OFFSET. The 'Add' member
+  // functions call the Finish member function of the object being
+  // added for you; if you are 'Add'ing this section, you needn't Finish it.
+  virtual void Finish(const Label &offset) { 
+    file_offset_ = offset; size_ = Size();
+  }
+
+ protected:
+  // This section's size and offset within the minidump file.
+  Label file_offset_, size_;
+};
+
+// A stream within a minidump file. 'Add'ing a stream to a minidump
+// creates an entry for it in the minidump's stream directory.
+class Stream: public Section {
+ public:
+  // Create a stream of type TYPE.  You can append whatever contents
+  // you like to this stream using the TestAssembler::Section methods.
+  Stream(const Dump &dump, u_int32_t type) : Section(dump), type_(type) { }
+
+  // Append an MDRawDirectory referring to this stream to SECTION.
+  void CiteStreamIn(TestAssembler::Section *section) const;
+
+ private:
+  // The type of this stream.
+  u_int32_t type_;
+};
+
+class SystemInfo: public Stream {
+ public:
+  // Create an MD_SYSTEM_INFO_STREAM stream belonging to DUMP holding
+  // an MDRawSystem info structure initialized with the values from
+  // SYSTEM_INFO, except that the csd_version field is replaced with
+  // the file offset of the string CSD_VERSION, which can be 'Add'ed
+  // to the dump at the desired location.
+  // 
+  // Remember that you are still responsible for 'Add'ing CSD_VERSION
+  // to the dump yourself.
+  SystemInfo(const Dump &dump,
+             const MDRawSystemInfo &system_info,
+             const String &csd_version);
+
+  // Stock MDRawSystemInfo information and associated strings, for
+  // writing tests.
+  static const MDRawSystemInfo windows_x86;
+  static const string windows_x86_csd_version;
+};
+
+// An MDString: a string predeced by a 32-bit length.
+class String: public Section {
+ public:
+  String(const Dump &dump, const string &value);
+
+  // Append an MDRVA referring to this string to SECTION.
+  void CiteStringIn(TestAssembler::Section *section) const;
+};
+
+// A range of memory contents. 'Add'ing a memory range to a minidump
+// creates n entry for it in the minidump's memory list. By
+// convention, the 'Start', 'Here', and 'Mark' member functions refer
+// to memory addresses.
+class Memory: public Section {
+ public:
+  Memory(const Dump &dump, u_int64_t address)
+      : Section(dump), address_(address) { Start() = address; }
+
+  // Append an MDMemoryDescriptor referring to this memory range to SECTION.
+  void CiteMemoryIn(TestAssembler::Section *section) const;
+
+ private:
+  // The process address from which these memory contents were taken.
+  // Shouldn't this be a Label?
+  u_int64_t address_;
+};
+
+class Context: public Section {
+ public:
+  // Create a context belonging to DUMP whose contents are a copy of CONTEXT.
+  Context(const Dump &dump, const MDRawContextX86 &context);
+  // Add constructors for other architectures here. Remember to byteswap.
+};
+
+class Thread: public Section {
+ public:
+  // Create a thread belonging to DUMP with the given values, citing
+  // STACK and CONTEXT (which you must Add to the dump separately).
+  Thread(const Dump &dump,
+         u_int32_t thread_id,
+         const Memory &stack,
+         const Context &context,
+         u_int32_t suspend_count = 0,
+         u_int32_t priority_class = 0,
+         u_int32_t priority = 0,
+         u_int64_t teb = 0);
+};
+
+class Module: public Section {
+ public:
+  // Create a module with the given values. Note that CV_RECORD and
+  // MISC_RECORD can be NULL, in which case the corresponding location
+  // descriptior in the minidump will have a length of zero.
+  Module(const Dump &dump,
+         u_int64_t base_of_image,
+         u_int32_t size_of_image,
+         const String &name,
+         u_int32_t time_date_stamp = 1262805309,
+         u_int32_t checksum = 0,
+         const MDVSFixedFileInfo &version_info = Module::stock_version_info,
+         const Section *cv_record = NULL,
+         const Section *misc_record = NULL);
+
+ private:
+  // A standard MDVSFixedFileInfo structure to use as a default for
+  // minidumps.  There's no reason to make users write out all this crap
+  // over and over.
+  static const MDVSFixedFileInfo stock_version_info;
+};
+
+// A list of entries starting with a 32-bit count, like a memory list
+// or a thread list.
+template<typename Element>
+class List: public Stream {
+ public:
+  List(const Dump &dump, u_int32_t type) : Stream(dump, type), count_(0) {
+    D32(count_label_);
+  }
+
+  // Add ELEMENT to this list.
+  void Add(Element *element) {
+    element->Finish(file_offset_ + Size());
+    Append(*element);
+    count_++;
+  }
+
+  // Return true if this List is empty, false otherwise.
+  bool Empty() { return count_ == 0; }
+
+  // Finish up the contents of this section, mark it as having been
+  // placed at OFFSET.
+  virtual void Finish(const Label &offset) {
+    Stream::Finish(offset);
+    count_label_ = count_;
+  }
+
+ private:
+  size_t count_;
+  Label count_label_;
+};
+
+class Dump: public TestAssembler::Section {
+ public:
+
+  // Create a TestAssembler::Section containing a minidump file whose
+  // header uses the given values. ENDIANNESS determines the
+  // endianness of the signature; we set this section's default
+  // endianness by this.
+  Dump(u_int64_t flags,
+       Endianness endianness = kLittleEndian,
+       u_int32_t version = MD_HEADER_VERSION,
+       u_int32_t date_time_stamp = 1262805309);
+
+  // The following functions call OBJECT->Finish(), and append the
+  // contents of OBJECT to this minidump. They also record OBJECT in
+  // whatever directory or list is appropriate for its type. The
+  // stream directory, memory list, thread list, and module list are
+  // accumulated this way.
+  Dump &Add(SynthMinidump::Section *object); // simply append data
+  Dump &Add(Stream *object); // append, record in stream directory
+  Dump &Add(Memory *object); // append, record in memory list
+  Dump &Add(Thread *object); // append, record in thread list
+  Dump &Add(Module *object); // append, record in module list
+
+  // Complete the construction of the minidump, given the Add calls
+  // we've seen up to this point. After this call, this Dump's
+  // contents are complete, all labels should be defined if everything
+  // Cited has been Added, and you may call GetContents on it.
+  void Finish();
+
+ private:
+  // A label representing the start of the minidump file.
+  Label file_start_;
+
+  // The stream directory.  We construct this incrementally from
+  // Add(Stream *) calls.
+  SynthMinidump::Section stream_directory_; // The directory's contents.
+  size_t stream_count_;                 // The number of streams so far.
+  Label stream_count_label_;            // Cited in file header.
+  Label stream_directory_rva_;          // The directory's file offset.
+
+  // This minidump's thread list. We construct this incrementally from
+  // Add(Thread *) calls.
+  List<Thread> thread_list_;
+
+  // This minidump's module list. We construct this incrementally from
+  // Add(Module *) calls.
+  List<Module> module_list_;
+
+  // This minidump's memory list. We construct this incrementally from
+  // Add(Memory *) calls. This is actually a list of MDMemoryDescriptors,
+  // not memory ranges --- thus the odd type.
+  List<SynthMinidump::Section> memory_list_;
+};
+
+} // namespace SynthMinidump
+
+} // namespace google_breakpad
+
+#endif  // PROCESSOR_SYNTH_MINIDUMP_H__