minidump: Migrate the rest of the tests to MinidumpWritableAtLocationDescriptor<>()

minidump/minidump_module_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_module_writer.h"
 
 #include <dbghelp.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "base/strings/utf_string_conversions.h"
 #include "gtest/gtest.h"
 #include "minidump/minidump_extensions.h"
 #include "minidump/minidump_file_writer.h"
 #include "minidump/test/minidump_file_writer_test_util.h"
 #include "minidump/test/minidump_string_writer_test_util.h"
+#include "minidump/test/minidump_writable_test_util.h"
 #include "util/file/string_file_writer.h"
 #include "util/misc/uuid.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 void GetModuleListStream(const std::string& file_contents,
                          const MINIDUMP_MODULE_LIST** module_list) {
   const size_t kDirectoryOffset = sizeof(MINIDUMP_HEADER);
   const size_t kModuleListStreamOffset =
       kDirectoryOffset + sizeof(MINIDUMP_DIRECTORY);
   const size_t kModulesOffset =
       kModuleListStreamOffset + sizeof(MINIDUMP_MODULE_LIST);
 
   ASSERT_GE(file_contents.size(), kModulesOffset);
 
   const MINIDUMP_DIRECTORY* directory;
   const MINIDUMP_HEADER* header =
       MinidumpHeaderAtStart(file_contents, &directory);
   ASSERT_NO_FATAL_FAILURE(VerifyMinidumpHeader(header, 1, 0));
   ASSERT_TRUE(directory);
 
   ASSERT_EQ(kMinidumpStreamTypeModuleList, directory[0].StreamType);
-  ASSERT_GE(directory[0].Location.DataSize, sizeof(MINIDUMP_MODULE_LIST));
-  ASSERT_EQ(kModuleListStreamOffset, directory[0].Location.Rva);
+  EXPECT_EQ(kModuleListStreamOffset, directory[0].Location.Rva);
 
-  *module_list = reinterpret_cast<const MINIDUMP_MODULE_LIST*>(
-      &file_contents[kModuleListStreamOffset]);
-
-  ASSERT_EQ(sizeof(MINIDUMP_MODULE_LIST) +
-                (*module_list)->NumberOfModules * sizeof(MINIDUMP_MODULE),
-            directory[0].Location.DataSize);
+  *module_list = MinidumpWritableAtLocationDescriptor<MINIDUMP_MODULE_LIST>(
+      file_contents, directory[0].Location);
+  ASSERT_TRUE(module_list);
 }
 
 TEST(MinidumpModuleWriter, EmptyModuleList) {
   MinidumpFileWriter minidump_file_writer;
   MinidumpModuleListWriter module_list_writer;
 
   minidump_file_writer.AddStream(&module_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
@@ skipping 15 matching lines @@
 // record must be a PDB 7.0 link, otherwise, it must be a PDB 2.0 link. If
 // |expected_pdb_name| is nullptr, |codeview_record| must not point to anything.
 void ExpectCodeViewRecord(const MINIDUMP_LOCATION_DESCRIPTOR* codeview_record,
                           const std::string& file_contents,
                           const char* expected_pdb_name,
                           const UUID* expected_pdb_uuid,
                           time_t expected_pdb_timestamp,
                           uint32_t expected_pdb_age) {
   if (expected_pdb_name) {
     EXPECT_NE(0u, codeview_record->Rva);
-    ASSERT_LE(codeview_record->Rva + codeview_record->DataSize,
-              file_contents.size());
 
     std::string observed_pdb_name;
     if (expected_pdb_uuid) {
       // The CodeView record should be a PDB 7.0 link.
-      EXPECT_GE(codeview_record->DataSize,
-                sizeof(MinidumpModuleCodeViewRecordPDB70));
       const MinidumpModuleCodeViewRecordPDB70* codeview_pdb70_record =
-          reinterpret_cast<const MinidumpModuleCodeViewRecordPDB70*>(
-              &file_contents[codeview_record->Rva]);
-      EXPECT_EQ(MinidumpModuleCodeViewRecordPDB70::kSignature,
-                codeview_pdb70_record->signature);
+          MinidumpWritableAtLocationDescriptor<
+              MinidumpModuleCodeViewRecordPDB70>(file_contents,
+                                                 *codeview_record);
+      ASSERT_TRUE(codeview_pdb70_record);
       EXPECT_EQ(0,
                 memcmp(expected_pdb_uuid,
                        &codeview_pdb70_record->uuid,
                        sizeof(codeview_pdb70_record->uuid)));
       EXPECT_EQ(expected_pdb_age, codeview_pdb70_record->age);
 
       observed_pdb_name.assign(
           reinterpret_cast<const char*>(&codeview_pdb70_record->pdb_name[0]),
           codeview_record->DataSize -
               offsetof(MinidumpModuleCodeViewRecordPDB70, pdb_name));
     } else {
       // The CodeView record should be a PDB 2.0 link.
-      EXPECT_GE(codeview_record->DataSize,
-                sizeof(MinidumpModuleCodeViewRecordPDB20));
       const MinidumpModuleCodeViewRecordPDB20* codeview_pdb20_record =
-          reinterpret_cast<const MinidumpModuleCodeViewRecordPDB20*>(
-              &file_contents[codeview_record->Rva]);
-      EXPECT_EQ(MinidumpModuleCodeViewRecordPDB20::kSignature,
-                codeview_pdb20_record->signature);
+          MinidumpWritableAtLocationDescriptor<
+              MinidumpModuleCodeViewRecordPDB20>(file_contents,
+                                                 *codeview_record);
+      ASSERT_TRUE(codeview_pdb20_record);
       EXPECT_EQ(static_cast<uint32_t>(expected_pdb_timestamp),
                 codeview_pdb20_record->timestamp);
       EXPECT_EQ(expected_pdb_age, codeview_pdb20_record->age);
 
       observed_pdb_name.assign(
           reinterpret_cast<const char*>(&codeview_pdb20_record->pdb_name[0]),
           codeview_record->DataSize -
               offsetof(MinidumpModuleCodeViewRecordPDB20, pdb_name));
     }
 
@@ skipping 13 matching lines @@
 // miscellanous debugging record in |file_contents|, and its fields are compared
 // against the the |expected_debug_*| values. If |expected_debug_name| is
 // nullptr, |misc_record| must not point to anything.
 void ExpectMiscellaneousDebugRecord(
     const MINIDUMP_LOCATION_DESCRIPTOR* misc_record,
     const std::string& file_contents,
     const char* expected_debug_name,
     uint32_t expected_debug_type,
     bool expected_debug_utf16) {
   if (expected_debug_name) {
-    EXPECT_GE(misc_record->DataSize, sizeof(IMAGE_DEBUG_MISC));
     EXPECT_NE(0u, misc_record->Rva);
-    ASSERT_LE(misc_record->Rva + misc_record->DataSize, file_contents.size());
     const IMAGE_DEBUG_MISC* misc_debug_record =
-        reinterpret_cast<const IMAGE_DEBUG_MISC*>(
-            &file_contents[misc_record->Rva]);
+        MinidumpWritableAtLocationDescriptor<IMAGE_DEBUG_MISC>(file_contents,
+                                                               *misc_record);
+    ASSERT_TRUE(misc_debug_record);
     EXPECT_EQ(expected_debug_type, misc_debug_record->DataType);
-    EXPECT_EQ(misc_record->DataSize, misc_debug_record->Length);
     EXPECT_EQ(expected_debug_utf16, misc_debug_record->Unicode);
     EXPECT_EQ(0u, misc_debug_record->Reserved[0]);
     EXPECT_EQ(0u, misc_debug_record->Reserved[1]);
     EXPECT_EQ(0u, misc_debug_record->Reserved[2]);
 
     // Check for the NUL terminator.
     size_t bytes_available =
         misc_debug_record->Length - offsetof(IMAGE_DEBUG_MISC, Data);
     EXPECT_EQ('\0', misc_debug_record->Data[bytes_available - 1]);
     std::string observed_data(
@@ skipping 439 matching lines @@
   module_list_writer.AddModule(&module_writer);
   minidump_file_writer.AddStream(&module_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_DEATH(minidump_file_writer.WriteEverything(&file_writer), "name_");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad