Add MinidumpMemoryWriter, MinidumpMemoryListWriter, and their test

minidump/minidump_file_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_file_writer.h"
 
 #include <dbghelp.h>
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "gtest/gtest.h"
 #include "minidump/minidump_stream_writer.h"
+#include "minidump/minidump_test_util.h"
 #include "minidump/minidump_writable.h"
 #include "util/file/file_writer.h"
 #include "util/file/string_file_writer.h"
 
 namespace {
 
 using namespace crashpad;
+using namespace crashpad::test;
 
 TEST(MinidumpFileWriter, Empty) {
   MinidumpFileWriter minidump_file;
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file.WriteEverything(&file_writer));
   ASSERT_EQ(sizeof(MINIDUMP_HEADER), file_writer.string().size());
 
   const MINIDUMP_HEADER* header =
       reinterpret_cast<const MINIDUMP_HEADER*>(&file_writer.string()[0]);
 
-  EXPECT_EQ(static_cast<uint32_t>(MINIDUMP_SIGNATURE), header->Signature);
-  EXPECT_EQ(static_cast<uint32_t>(MINIDUMP_VERSION), header->Version);
-  EXPECT_EQ(0u, header->NumberOfStreams);
-  EXPECT_EQ(0u, header->StreamDirectoryRva);
-  EXPECT_EQ(0u, header->CheckSum);
-  EXPECT_EQ(0u, header->TimeDateStamp);
-  EXPECT_EQ(MiniDumpNormal, header->Flags);
+  VerifyMinidumpHeader(header, 0, 0);
+  if (Test::HasFatalFailure()) {
+    return;
+  }
 }
 
 class TestStream final : public internal::MinidumpStreamWriter {
  public:
   TestStream(MinidumpStreamType stream_type,
              size_t stream_size,
              uint8_t stream_value)
       : stream_data_(stream_size, stream_value), stream_type_(stream_type) {}
 
   ~TestStream() {}
@@ skipping 38 matching lines @@
 
   const size_t kDirectoryOffset = sizeof(MINIDUMP_HEADER);
   const size_t kStreamOffset = kDirectoryOffset + sizeof(MINIDUMP_DIRECTORY);
   const size_t kFileSize = kStreamOffset + kStreamSize;
 
   ASSERT_EQ(kFileSize, file_writer.string().size());
 
   const MINIDUMP_HEADER* header =
       reinterpret_cast<const MINIDUMP_HEADER*>(&file_writer.string()[0]);
 
-  EXPECT_EQ(static_cast<uint32_t>(MINIDUMP_SIGNATURE), header->Signature);
-  EXPECT_EQ(static_cast<uint32_t>(MINIDUMP_VERSION), header->Version);
-  EXPECT_EQ(1u, header->NumberOfStreams);
-  EXPECT_EQ(kDirectoryOffset, header->StreamDirectoryRva);
-  EXPECT_EQ(0u, header->CheckSum);
-  EXPECT_EQ(kTimestamp, header->TimeDateStamp);
-  EXPECT_EQ(MiniDumpNormal, header->Flags);
+  VerifyMinidumpHeader(header, 1, kTimestamp);
+  if (Test::HasFatalFailure()) {
+    return;
+  }
 
   const MINIDUMP_DIRECTORY* directory =
       reinterpret_cast<const MINIDUMP_DIRECTORY*>(
           &file_writer.string()[kDirectoryOffset]);
 
   EXPECT_EQ(kStreamType, directory->StreamType);
   EXPECT_EQ(kStreamSize, directory->Location.DataSize);
   EXPECT_EQ(kStreamOffset, directory->Location.Rva);
 
   const uint8_t* stream_data =
@@ skipping 39 matching lines @@
   const size_t kStream2Offset = kStream1Offset + kStream1Size + kStream2Padding;
   const size_t kStream3Padding = 1;
   const size_t kStream3Offset = kStream2Offset + kStream2Size + kStream3Padding;
   const size_t kFileSize = kStream3Offset + kStream3Size;
 
   ASSERT_EQ(kFileSize, file_writer.string().size());
 
   const MINIDUMP_HEADER* header =
       reinterpret_cast<const MINIDUMP_HEADER*>(&file_writer.string()[0]);
 
-  EXPECT_EQ(static_cast<uint32_t>(MINIDUMP_SIGNATURE), header->Signature);
-  EXPECT_EQ(static_cast<uint32_t>(MINIDUMP_VERSION), header->Version);
-  EXPECT_EQ(3u, header->NumberOfStreams);
-  EXPECT_EQ(kDirectoryOffset, header->StreamDirectoryRva);
-  EXPECT_EQ(0u, header->CheckSum);
-  EXPECT_EQ(kTimestamp, header->TimeDateStamp);
-  EXPECT_EQ(MiniDumpNormal, header->Flags);
+  VerifyMinidumpHeader(header, 3, kTimestamp);
+  if (Test::HasFatalFailure()) {
+    return;
+  }
 
   const MINIDUMP_DIRECTORY* directory =
       reinterpret_cast<const MINIDUMP_DIRECTORY*>(
           &file_writer.string()[kDirectoryOffset]);
 
   EXPECT_EQ(kStream1Type, directory[0].StreamType);
   EXPECT_EQ(kStream1Size, directory[0].Location.DataSize);
   EXPECT_EQ(kStream1Offset, directory[0].Location.Rva);
   EXPECT_EQ(kStream2Type, directory[1].StreamType);
   EXPECT_EQ(kStream2Size, directory[1].Location.DataSize);
@@ skipping 21 matching lines @@
   ASSERT_GE(sizeof(kZeroes), kStream3Padding);
   EXPECT_EQ(0, memcmp(stream2_data + kStream2Size, kZeroes, kStream3Padding));
 
   const uint8_t* stream3_data =
       reinterpret_cast<const uint8_t*>(&file_writer.string()[kStream3Offset]);
 
   std::string expected_stream3(kStream3Size, kStream3Value);
   EXPECT_EQ(0, memcmp(stream3_data, expected_stream3.c_str(), kStream3Size));
 }
 
+TEST(MinidumpFileWriter, ZeroLengthStream) {
+  MinidumpFileWriter minidump_file;
+
+  const size_t kStreamSize = 0;
+  const MinidumpStreamType kStreamType = static_cast<MinidumpStreamType>(0x4d);
+  TestStream stream(kStreamType, kStreamSize, 0);
+  minidump_file.AddStream(&stream);
+
+  StringFileWriter file_writer;
+  ASSERT_TRUE(minidump_file.WriteEverything(&file_writer));
+
+  const size_t kDirectoryOffset = sizeof(MINIDUMP_HEADER);
+  const size_t kStreamOffset = kDirectoryOffset + sizeof(MINIDUMP_DIRECTORY);
+  const size_t kFileSize = kStreamOffset + kStreamSize;
+
+  ASSERT_EQ(kFileSize, file_writer.string().size());
+
+  const MINIDUMP_HEADER* header =
+      reinterpret_cast<const MINIDUMP_HEADER*>(&file_writer.string()[0]);
+
+  VerifyMinidumpHeader(header, 1, 0);
+  if (Test::HasFatalFailure()) {
+    return;
+  }
+
+  const MINIDUMP_DIRECTORY* directory =
+      reinterpret_cast<const MINIDUMP_DIRECTORY*>(
+          &file_writer.string()[kDirectoryOffset]);
+
+  EXPECT_EQ(kStreamType, directory->StreamType);
+  EXPECT_EQ(kStreamSize, directory->Location.DataSize);
+  EXPECT_EQ(kStreamOffset, directory->Location.Rva);
+}
+
 TEST(MinidumpFileWriterDeathTest, SameStreamType) {
   MinidumpFileWriter minidump_file;
 
   const size_t kStream1Size = 5;
   const MinidumpStreamType kStream1Type = static_cast<MinidumpStreamType>(0x4d);
   const uint8_t kStream1Value = 0x5a;
   TestStream stream1(kStream1Type, kStream1Size, kStream1Value);
   minidump_file.AddStream(&stream1);
 
   // It is an error to add a second stream of the same type.
   const size_t kStream2Size = 3;
   const MinidumpStreamType kStream2Type = static_cast<MinidumpStreamType>(0x4d);
   const uint8_t kStream2Value = 0xa5;
   TestStream stream2(kStream2Type, kStream2Size, kStream2Value);
   ASSERT_DEATH(minidump_file.AddStream(&stream2), "already present");
 }
 
 }  // namespace