Add MinidumpModuleWriter, MinidumpModuleListWriter, related classes, and their test

minidump/minidump_memory_writer_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "minidump/minidump_memory_writer.h"
 
 #include <dbghelp.h>
 #include <stdint.h>
 
 #include "base/basictypes.h"
 #include "gtest/gtest.h"
+#include "minidump/minidump_extensions.h"
 #include "minidump/minidump_file_writer.h"
 #include "minidump/minidump_stream_writer.h"
 #include "minidump/minidump_test_util.h"
 #include "util/file/string_file_writer.h"
 
 namespace {
 
 using namespace crashpad;
 using namespace crashpad::test;
 
@@ skipping 209 matching lines @@
 
   const MINIDUMP_MEMORY_LIST* memory_list;
   GetMemoryListStream(file_writer.string(), &memory_list, 1);
   if (Test::HasFatalFailure()) {
     return;
   }
 
   EXPECT_EQ(2u, memory_list->NumberOfMemoryRanges);
 
   MINIDUMP_MEMORY_DESCRIPTOR expected;
-  expected.StartOfMemoryRange = kBaseAddress1;
-  expected.Memory.DataSize = kSize1;
-  expected.Memory.Rva =
-      sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
-      sizeof(MINIDUMP_MEMORY_LIST) +
-      memory_list->NumberOfMemoryRanges * sizeof(MINIDUMP_MEMORY_DESCRIPTOR);
-  ExpectMemoryDescriptorAndContents(&expected,
-                                    &memory_list->MemoryRanges[0],
-                                    file_writer.string(),
-                                    kValue1,
-                                    false);
 
-  expected.StartOfMemoryRange = kBaseAddress2;
-  expected.Memory.DataSize = kSize2;
-  expected.Memory.Rva = memory_list->MemoryRanges[0].Memory.Rva +
-                        memory_list->MemoryRanges[0].Memory.DataSize;
-  ExpectMemoryDescriptorAndContents(&expected,
-                                    &memory_list->MemoryRanges[1],
-                                    file_writer.string(),
-                                    kValue2,
-                                    true);
+  {
+    SCOPED_TRACE("region 0");
+
+    expected.StartOfMemoryRange = kBaseAddress1;
+    expected.Memory.DataSize = kSize1;
+    expected.Memory.Rva =
+        sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
+        sizeof(MINIDUMP_MEMORY_LIST) +
+        memory_list->NumberOfMemoryRanges * sizeof(MINIDUMP_MEMORY_DESCRIPTOR);
+    ExpectMemoryDescriptorAndContents(&expected,
+                                      &memory_list->MemoryRanges[0],
+                                      file_writer.string(),
+                                      kValue1,
+                                      false);
+  }
+
+  {
+    SCOPED_TRACE("region 1");
+
+    expected.StartOfMemoryRange = kBaseAddress2;
+    expected.Memory.DataSize = kSize2;
+    expected.Memory.Rva = memory_list->MemoryRanges[0].Memory.Rva +
+                          memory_list->MemoryRanges[0].Memory.DataSize;
+    ExpectMemoryDescriptorAndContents(&expected,
+                                      &memory_list->MemoryRanges[1],
+                                      file_writer.string(),
+                                      kValue2,
+                                      true);
+  }
 }
 
 class TestMemoryStream final : public internal::MinidumpStreamWriter {
  public:
   TestMemoryStream(uint64_t base_address, size_t size, uint8_t value)
       : MinidumpStreamWriter(), memory_(base_address, size, value) {}
 
   ~TestMemoryStream() {}
 
   TestMemoryWriter* memory() { return &memory_; }
@@ skipping 57 matching lines @@
 
   const MINIDUMP_MEMORY_LIST* memory_list;
   GetMemoryListStream(file_writer.string(), &memory_list, 2);
   if (Test::HasFatalFailure()) {
     return;
   }
 
   EXPECT_EQ(2u, memory_list->NumberOfMemoryRanges);
 
   MINIDUMP_MEMORY_DESCRIPTOR expected;
-  expected.StartOfMemoryRange = kBaseAddress1;
-  expected.Memory.DataSize = kSize1;
-  expected.Memory.Rva =
-      sizeof(MINIDUMP_HEADER) + 2 * sizeof(MINIDUMP_DIRECTORY) +
-      sizeof(MINIDUMP_MEMORY_LIST) +
-      memory_list->NumberOfMemoryRanges * sizeof(MINIDUMP_MEMORY_DESCRIPTOR);
-  ExpectMemoryDescriptorAndContents(&expected,
-                                    &memory_list->MemoryRanges[0],
-                                    file_writer.string(),
-                                    kValue1,
-                                    false);
 
-  expected.StartOfMemoryRange = kBaseAddress2;
-  expected.Memory.DataSize = kSize2;
-  expected.Memory.Rva = memory_list->MemoryRanges[0].Memory.Rva +
-                        memory_list->MemoryRanges[0].Memory.DataSize;
-  ExpectMemoryDescriptorAndContents(&expected,
-                                    &memory_list->MemoryRanges[1],
-                                    file_writer.string(),
-                                    kValue2,
-                                    true);
+  {
+    SCOPED_TRACE("region 0");
+
+    expected.StartOfMemoryRange = kBaseAddress1;
+    expected.Memory.DataSize = kSize1;
+    expected.Memory.Rva =
+        sizeof(MINIDUMP_HEADER) + 2 * sizeof(MINIDUMP_DIRECTORY) +
+        sizeof(MINIDUMP_MEMORY_LIST) +
+        memory_list->NumberOfMemoryRanges * sizeof(MINIDUMP_MEMORY_DESCRIPTOR);
+    ExpectMemoryDescriptorAndContents(&expected,
+                                      &memory_list->MemoryRanges[0],
+                                      file_writer.string(),
+                                      kValue1,
+                                      false);
+  }
+
+  {
+    SCOPED_TRACE("region 1");
+
+    expected.StartOfMemoryRange = kBaseAddress2;
+    expected.Memory.DataSize = kSize2;
+    expected.Memory.Rva = memory_list->MemoryRanges[0].Memory.Rva +
+                          memory_list->MemoryRanges[0].Memory.DataSize;
+    ExpectMemoryDescriptorAndContents(&expected,
+                                      &memory_list->MemoryRanges[1],
+                                      file_writer.string(),
+                                      kValue2,
+                                      true);
+  }
 }
 
 }  // namespace