Refactor minidump test utilities for MinidumpWritable, …

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,
@@ skipping 29 matching lines @@
                          const MINIDUMP_MEMORY_LIST** memory_list,
                          const uint32_t expected_streams) {
   const size_t kDirectoryOffset = sizeof(MINIDUMP_HEADER);
   const size_t kMemoryListStreamOffset =
       kDirectoryOffset + expected_streams * sizeof(MINIDUMP_DIRECTORY);
   const size_t kMemoryDescriptorsOffset =
       kMemoryListStreamOffset + sizeof(MINIDUMP_MEMORY_LIST);
 
   ASSERT_GE(file_contents.size(), kMemoryDescriptorsOffset);
 
+  const MINIDUMP_DIRECTORY* directory;
   const MINIDUMP_HEADER* header =
-      reinterpret_cast<const MINIDUMP_HEADER*>(&file_contents[0]);
+      MinidumpHeaderAtStart(file_contents, &directory);
+  ASSERT_NO_FATAL_FAILURE(VerifyMinidumpHeader(header, expected_streams, 0));
+  ASSERT_TRUE(directory);
 
-  ASSERT_NO_FATAL_FAILURE(VerifyMinidumpHeader(header, expected_streams, 0));
-
-  const MINIDUMP_DIRECTORY* directory =
-      reinterpret_cast<const MINIDUMP_DIRECTORY*>(
-          &file_contents[kDirectoryOffset]);
-
+  size_t directory_index = 0;
   if (expected_streams > 1) {
-    ASSERT_EQ(kBogusStreamType, directory->StreamType);
-    ASSERT_EQ(0u, directory->Location.DataSize);
-    ASSERT_EQ(kMemoryListStreamOffset, directory->Location.Rva);
-    ++directory;
+    ASSERT_EQ(kBogusStreamType, directory[directory_index].StreamType);
+    ASSERT_EQ(0u, directory[directory_index].Location.DataSize);
+    ASSERT_EQ(kMemoryListStreamOffset, directory[directory_index].Location.Rva);
+    ++directory_index;
   }
 
-  ASSERT_EQ(kMinidumpStreamTypeMemoryList, directory->StreamType);
-  ASSERT_GE(directory->Location.DataSize, sizeof(MINIDUMP_MEMORY_LIST));
-  ASSERT_EQ(kMemoryListStreamOffset, directory->Location.Rva);
+  ASSERT_EQ(kMinidumpStreamTypeMemoryList,
+            directory[directory_index].StreamType);
+  ASSERT_GE(directory[directory_index].Location.DataSize,
+            sizeof(MINIDUMP_MEMORY_LIST));
+  ASSERT_EQ(kMemoryListStreamOffset, directory[directory_index].Location.Rva);
 
   *memory_list = reinterpret_cast<const MINIDUMP_MEMORY_LIST*>(
       &file_contents[kMemoryListStreamOffset]);
 
   ASSERT_EQ(sizeof(MINIDUMP_MEMORY_LIST) +
                 (*memory_list)->NumberOfMemoryRanges *
                     sizeof(MINIDUMP_MEMORY_DESCRIPTOR),
-            directory->Location.DataSize);
+            directory[directory_index].Location.DataSize);
 }
 
 TEST(MinidumpMemoryWriter, EmptyMemoryList) {
   MinidumpFileWriter minidump_file_writer;
   MinidumpMemoryListWriter memory_list_writer;
 
   minidump_file_writer.AddStream(&memory_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
@@ skipping 204 matching lines @@
                                               &memory_list->MemoryRanges[1],
                                               file_writer.string(),
                                               kValue1,
                                               true);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad