Add MinidumpFileWriter::InitializeFromSnapshot() and its tests

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_writable.h"
 #include "minidump/test/minidump_file_writer_test_util.h"
 #include "minidump/test/minidump_writable_test_util.h"
+#include "snapshot/test/test_cpu_context.h"
+#include "snapshot/test/test_exception_snapshot.h"
+#include "snapshot/test/test_module_snapshot.h"
+#include "snapshot/test/test_process_snapshot.h"
+#include "snapshot/test/test_system_snapshot.h"
+#include "snapshot/test/test_thread_snapshot.h"
 #include "util/file/file_writer.h"
 #include "util/file/string_file_writer.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 TEST(MinidumpFileWriter, Empty) {
   MinidumpFileWriter minidump_file;
   StringFileWriter file_writer;
@@ skipping 188 matching lines @@
   const MINIDUMP_HEADER* header =
       MinidumpHeaderAtStart(file_writer.string(), &directory);
   ASSERT_NO_FATAL_FAILURE(VerifyMinidumpHeader(header, 1, 0));
   ASSERT_TRUE(directory);
 
   EXPECT_EQ(kStreamType, directory[0].StreamType);
   EXPECT_EQ(kStreamSize, directory[0].Location.DataSize);
   EXPECT_EQ(kStreamOffset, directory[0].Location.Rva);
 }
 
+TEST(MinidumpFileWriter, InitializeFromSnapshot_Basic) {
+  const uint32_t kSnapshotTime = 0x4976043c;
+  const timeval kSnapshotTimeval = { implicit_cast<time_t>(kSnapshotTime), 0 };
+
+  TestProcessSnapshot process_snapshot;
+  process_snapshot.SetSnapshotTime(kSnapshotTimeval);
+
+  auto system_snapshot = make_scoped_ptr(new TestSystemSnapshot());
+  system_snapshot->SetCPUArchitecture(kCPUArchitectureX86_64);
+  system_snapshot->SetOperatingSystem(SystemSnapshot::kOperatingSystemMacOSX);
+  process_snapshot.SetSystem(system_snapshot.Pass());
+
+  MinidumpFileWriter minidump_file_writer;
+  minidump_file_writer.InitializeFromSnapshot(&process_snapshot);
+
+  StringFileWriter file_writer;
+  ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
+
+  const MINIDUMP_DIRECTORY* directory;
+  const MINIDUMP_HEADER* header =
+      MinidumpHeaderAtStart(file_writer.string(), &directory);
+  ASSERT_NO_FATAL_FAILURE(VerifyMinidumpHeader(header, 5, kSnapshotTime));
+  ASSERT_TRUE(directory);
+
+  EXPECT_EQ(kMinidumpStreamTypeSystemInfo, directory[0].StreamType);

[Robert Sesek, 2014/11/07 17:07:47]

Is there any significance to the order in which the streams are added, since
you're checking that here?

+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_SYSTEM_INFO>(
+                  file_writer.string(), directory[0].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeMiscInfo, directory[1].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_MISC_INFO_4>(
+                  file_writer.string(), directory[1].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeThreadList, directory[2].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_THREAD_LIST>(
+                  file_writer.string(), directory[2].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeModuleList, directory[3].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_MODULE_LIST>(
+                  file_writer.string(), directory[3].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeMemoryList, directory[4].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_MEMORY_LIST>(
+                  file_writer.string(), directory[4].Location));
+}
+
+TEST(MinidumpFileWriter, InitializeFromSnapshot_Exception) {
+  // In a 32-bit environment, this will give a “timestamp out of range” warning,
+  // but the test should complete without failure.
+  const uint32_t kSnapshotTime = 0xfd469ab8;
+  const timeval kSnapshotTimeval = { implicit_cast<time_t>(kSnapshotTime), 0 };
+
+  TestProcessSnapshot process_snapshot;
+  process_snapshot.SetSnapshotTime(kSnapshotTimeval);
+
+  auto system_snapshot = make_scoped_ptr(new TestSystemSnapshot());
+  system_snapshot->SetCPUArchitecture(kCPUArchitectureX86_64);
+  system_snapshot->SetOperatingSystem(SystemSnapshot::kOperatingSystemMacOSX);
+  process_snapshot.SetSystem(system_snapshot.Pass());
+
+  auto thread_snapshot = make_scoped_ptr(new TestThreadSnapshot());
+  InitializeCPUContextX86_64(thread_snapshot->MutableContext(), 5);
+  process_snapshot.AddThread(thread_snapshot.Pass());
+
+  auto exception_snapshot = make_scoped_ptr(new TestExceptionSnapshot());
+  InitializeCPUContextX86_64(exception_snapshot->MutableContext(), 11);
+  process_snapshot.SetException(exception_snapshot.Pass());
+
+  MinidumpFileWriter minidump_file_writer;
+  minidump_file_writer.InitializeFromSnapshot(&process_snapshot);
+
+  StringFileWriter file_writer;
+  ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
+
+  const MINIDUMP_DIRECTORY* directory;
+  const MINIDUMP_HEADER* header =
+      MinidumpHeaderAtStart(file_writer.string(), &directory);
+  ASSERT_NO_FATAL_FAILURE(VerifyMinidumpHeader(header, 6, kSnapshotTime));
+  ASSERT_TRUE(directory);
+
+  EXPECT_EQ(kMinidumpStreamTypeSystemInfo, directory[0].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_SYSTEM_INFO>(
+                  file_writer.string(), directory[0].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeMiscInfo, directory[1].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_MISC_INFO_4>(
+                  file_writer.string(), directory[1].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeThreadList, directory[2].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_THREAD_LIST>(
+                  file_writer.string(), directory[2].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeException, directory[3].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_EXCEPTION_STREAM>(
+                  file_writer.string(), directory[3].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeModuleList, directory[4].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_MODULE_LIST>(
+                  file_writer.string(), directory[4].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeMemoryList, directory[5].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_MEMORY_LIST>(
+                  file_writer.string(), directory[5].Location));
+}
+
+TEST(MinidumpFileWriter, InitializeFromSnapshot_CrashpadInfo) {
+  const uint32_t kSnapshotTime = 0x15393bd3;
+  const timeval kSnapshotTimeval = { implicit_cast<time_t>(kSnapshotTime), 0 };
+
+  TestProcessSnapshot process_snapshot;
+  process_snapshot.SetSnapshotTime(kSnapshotTimeval);
+
+  auto system_snapshot = make_scoped_ptr(new TestSystemSnapshot());
+  system_snapshot->SetCPUArchitecture(kCPUArchitectureX86_64);
+  system_snapshot->SetOperatingSystem(SystemSnapshot::kOperatingSystemMacOSX);
+  process_snapshot.SetSystem(system_snapshot.Pass());
+
+  auto thread_snapshot = make_scoped_ptr(new TestThreadSnapshot());
+  InitializeCPUContextX86_64(thread_snapshot->MutableContext(), 5);
+  process_snapshot.AddThread(thread_snapshot.Pass());
+
+  auto exception_snapshot = make_scoped_ptr(new TestExceptionSnapshot());
+  InitializeCPUContextX86_64(exception_snapshot->MutableContext(), 11);
+  process_snapshot.SetException(exception_snapshot.Pass());
+
+  // The module needs an annotation for the MinidumpCrashpadInfo stream to be

[Robert Sesek, 2014/11/07 17:07:47]

May want to test a !IsUseful() module, too.

+  // considered useful and be included.
+  auto module_snapshot = make_scoped_ptr(new TestModuleSnapshot());
+  std::vector<std::string> annotations_list(1, std::string("annotation"));
+  module_snapshot->SetAnnotationsVector(annotations_list);
+  process_snapshot.AddModule(module_snapshot.Pass());
+
+  MinidumpFileWriter minidump_file_writer;
+  minidump_file_writer.InitializeFromSnapshot(&process_snapshot);
+
+  StringFileWriter file_writer;
+  ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
+
+  const MINIDUMP_DIRECTORY* directory;
+  const MINIDUMP_HEADER* header =
+      MinidumpHeaderAtStart(file_writer.string(), &directory);
+  ASSERT_NO_FATAL_FAILURE(VerifyMinidumpHeader(header, 7, kSnapshotTime));
+  ASSERT_TRUE(directory);
+
+  EXPECT_EQ(kMinidumpStreamTypeSystemInfo, directory[0].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_SYSTEM_INFO>(
+                  file_writer.string(), directory[0].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeMiscInfo, directory[1].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_MISC_INFO_4>(
+                  file_writer.string(), directory[1].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeThreadList, directory[2].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_THREAD_LIST>(
+                  file_writer.string(), directory[2].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeException, directory[3].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_EXCEPTION_STREAM>(
+                  file_writer.string(), directory[3].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeModuleList, directory[4].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_MODULE_LIST>(
+                  file_writer.string(), directory[4].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeCrashpadInfo, directory[5].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MinidumpCrashpadInfo>(
+                  file_writer.string(), directory[5].Location));
+
+  EXPECT_EQ(kMinidumpStreamTypeMemoryList, directory[6].StreamType);
+  EXPECT_TRUE(MinidumpWritableAtLocationDescriptor<MINIDUMP_MEMORY_LIST>(
+                  file_writer.string(), directory[6].Location));
+}
+
 TEST(MinidumpFileWriterDeathTest, SameStreamType) {
   MinidumpFileWriter minidump_file;
 
   const size_t kStream0Size = 5;
   const MinidumpStreamType kStream0Type = static_cast<MinidumpStreamType>(0x4d);
   const uint8_t kStream0Value = 0x5a;
   auto stream0 = make_scoped_ptr(
       new TestStream(kStream0Type, kStream0Size, kStream0Value));
   minidump_file.AddStream(stream0.Pass());
 
   // It is an error to add a second stream of the same type.
   const size_t kStream1Size = 3;
   const MinidumpStreamType kStream1Type = static_cast<MinidumpStreamType>(0x4d);
   const uint8_t kStream1Value = 0xa5;
   auto stream1 = make_scoped_ptr(
       new TestStream(kStream1Type, kStream1Size, kStream1Value));
   ASSERT_DEATH(minidump_file.AddStream(stream1.Pass()), "already present");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad