Pull test utilities from MinidumpMemoryWriter’s test out into their own file

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_memory_writer_test_util.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;
 
 const MinidumpStreamType kBogusStreamType =
@@ skipping 60 matching lines @@
 
   const MINIDUMP_MEMORY_LIST* memory_list;
   GetMemoryListStream(file_writer.string(), &memory_list, 1);
   if (Test::HasFatalFailure()) {
     return;
   }
 
   EXPECT_EQ(0u, memory_list->NumberOfMemoryRanges);
 }
 
-class TestMemoryWriter final : public MinidumpMemoryWriter {
- public:
-  TestMemoryWriter(uint64_t base_address, size_t size, uint8_t value)
-      : MinidumpMemoryWriter(),
-        base_address_(base_address),
-        expected_offset_(-1),
-        size_(size),
-        value_(value) {}
-
-  ~TestMemoryWriter() {}
-
- protected:
-  // MinidumpMemoryWriter:
-  virtual uint64_t MemoryRangeBaseAddress() const override {
-    EXPECT_EQ(state(), kStateFrozen);
-    return base_address_;
-  }
-
-  virtual size_t MemoryRangeSize() const override {
-    EXPECT_GE(state(), kStateFrozen);
-    return size_;
-  }
-
-  // MinidumpWritable:
-  virtual bool WillWriteAtOffsetImpl(off_t offset) override {
-    EXPECT_EQ(state(), kStateFrozen);
-    expected_offset_ = offset;
-    bool rv = MinidumpMemoryWriter::WillWriteAtOffsetImpl(offset);
-    EXPECT_TRUE(rv);
-    return rv;
-  }
-
-  virtual bool WriteObject(FileWriterInterface* file_writer) override {
-    EXPECT_EQ(state(), kStateWritable);
-    EXPECT_EQ(expected_offset_, file_writer->Seek(0, SEEK_CUR));
-
-    bool rv = true;
-    if (size_ > 0) {
-      std::string data(size_, value_);
-      rv = file_writer->Write(&data[0], size_);
-      EXPECT_TRUE(rv);
-    }
-
-    return rv;
-  }
-
- private:
-  uint64_t base_address_;
-  off_t expected_offset_;
-  size_t size_;
-  uint8_t value_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestMemoryWriter);
-};
-
-void ExpectMemoryDescriptorAndContents(
-    const MINIDUMP_MEMORY_DESCRIPTOR* expected,
-    const MINIDUMP_MEMORY_DESCRIPTOR* observed,
-    const std::string& file_contents,
-    uint8_t value,
-    bool at_eof) {
-  const uint32_t kMemoryAlignment = 16;
-
-  EXPECT_EQ(expected->StartOfMemoryRange, observed->StartOfMemoryRange);
-  EXPECT_EQ(expected->Memory.DataSize, observed->Memory.DataSize);
-  EXPECT_EQ(
-      (expected->Memory.Rva + kMemoryAlignment - 1) & ~(kMemoryAlignment - 1),
-      observed->Memory.Rva);
-  if (at_eof) {
-    EXPECT_EQ(file_contents.size(),
-              observed->Memory.Rva + observed->Memory.DataSize);
-  } else {
-    EXPECT_GE(file_contents.size(),
-              observed->Memory.Rva + observed->Memory.DataSize);
-  }
-
-  std::string expected_data(expected->Memory.DataSize, value);
-  std::string observed_data(&file_contents[observed->Memory.Rva],
-                            observed->Memory.DataSize);
-  EXPECT_EQ(expected_data, observed_data);
-}
-
 TEST(MinidumpMemoryWriter, OneMemoryRegion) {
   MinidumpFileWriter minidump_file_writer;
   MinidumpMemoryListWriter memory_list_writer;
 
   const uint64_t kBaseAddress = 0xfedcba9876543210;
   const uint64_t kSize = 0x1000;
   const uint8_t kValue = 'm';
 
-  TestMemoryWriter memory_writer(kBaseAddress, kSize, kValue);
+  TestMinidumpMemoryWriter memory_writer(kBaseAddress, kSize, kValue);
   memory_list_writer.AddMemory(&memory_writer);
 
   minidump_file_writer.AddStream(&memory_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   const MINIDUMP_MEMORY_LIST* memory_list;
   GetMemoryListStream(file_writer.string(), &memory_list, 1);
   if (Test::HasFatalFailure()) {
     return;
   }
 
   MINIDUMP_MEMORY_DESCRIPTOR expected;
   expected.StartOfMemoryRange = kBaseAddress;
   expected.Memory.DataSize = kSize;
   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(),
-                                    kValue,
-                                    true);
+  ExpectMinidumpMemoryDescriptorAndContents(&expected,
+                                            &memory_list->MemoryRanges[0],
+                                            file_writer.string(),
+                                            kValue,
+                                            true);
 }
 
 TEST(MinidumpMemoryWriter, TwoMemoryRegions) {
   MinidumpFileWriter minidump_file_writer;
   MinidumpMemoryListWriter memory_list_writer;
 
   const uint64_t kBaseAddress1 = 0xc0ffee;
   const uint64_t kSize1 = 0x0100;
   const uint8_t kValue1 = '6';
   const uint64_t kBaseAddress2 = 0xfac00fac;
   const uint64_t kSize2 = 0x0200;
   const uint8_t kValue2 = '!';
 
-  TestMemoryWriter memory_writer_1(kBaseAddress1, kSize1, kValue1);
+  TestMinidumpMemoryWriter memory_writer_1(kBaseAddress1, kSize1, kValue1);
   memory_list_writer.AddMemory(&memory_writer_1);
-  TestMemoryWriter memory_writer_2(kBaseAddress2, kSize2, kValue2);
+  TestMinidumpMemoryWriter memory_writer_2(kBaseAddress2, kSize2, kValue2);
   memory_list_writer.AddMemory(&memory_writer_2);
 
   minidump_file_writer.AddStream(&memory_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   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;
 
   {
     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);
+    ExpectMinidumpMemoryDescriptorAndContents(&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);
+    ExpectMinidumpMemoryDescriptorAndContents(&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_; }
+  TestMinidumpMemoryWriter* memory() { return &memory_; }
 
   // MinidumpStreamWriter:
   virtual MinidumpStreamType StreamType() const override {
     return kBogusStreamType;
   }
 
  protected:
   // MinidumpWritable:
   virtual size_t SizeOfObject() override {
     EXPECT_GE(state(), kStateFrozen);
     return 0;
   }
 
   virtual std::vector<MinidumpWritable*> Children() override {
     EXPECT_GE(state(), kStateFrozen);
     std::vector<MinidumpWritable*> children(1, memory());
     return children;
   }
 
   virtual bool WriteObject(FileWriterInterface* file_writer) override {
     EXPECT_EQ(kStateWritable, state());
     return true;
   }
 
  private:
-  TestMemoryWriter memory_;
+  TestMinidumpMemoryWriter memory_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMemoryStream);
 };
 
 TEST(MinidumpMemoryWriter, ExtraMemory) {
   // This tests MinidumpMemoryListWriter::AddExtraMemory(). That method adds
   // a MinidumpMemoryWriter to the MinidumpMemoryListWriter without making the
   // memory writer a child of the memory list writer.
   MinidumpFileWriter minidump_file_writer;
 
   const uint64_t kBaseAddress1 = 0x1000;
   const uint64_t kSize1 = 0x0400;
   const uint8_t kValue1 = '1';
   TestMemoryStream test_memory_stream(kBaseAddress1, kSize1, kValue1);
 
   MinidumpMemoryListWriter memory_list_writer;
   memory_list_writer.AddExtraMemory(test_memory_stream.memory());
 
   minidump_file_writer.AddStream(&test_memory_stream);
 
   const uint64_t kBaseAddress2 = 0x2000;
   const uint64_t kSize2 = 0x0400;
   const uint8_t kValue2 = 'm';
 
-  TestMemoryWriter memory_writer(kBaseAddress2, kSize2, kValue2);
+  TestMinidumpMemoryWriter memory_writer(kBaseAddress2, kSize2, kValue2);
   memory_list_writer.AddMemory(&memory_writer);
 
   minidump_file_writer.AddStream(&memory_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   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;
 
   {
     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);
+    ExpectMinidumpMemoryDescriptorAndContents(&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);
+    ExpectMinidumpMemoryDescriptorAndContents(&expected,
+                                              &memory_list->MemoryRanges[1],
+                                              file_writer.string(),
+                                              kValue2,
+                                              true);
   }
 }
 
 }  // namespace