Add MinidumpCrashpadInfoWriter and its test

minidump/minidump_simple_string_dictionary_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_simple_string_dictionary_writer.h"
 
 #include <string>
 
 #include "gtest/gtest.h"
 #include "minidump/minidump_extensions.h"
+#include "minidump/minidump_string_writer_test_util.h"
 #include "util/file/string_file_writer.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 const MinidumpSimpleStringDictionary* MinidumpSimpleStringDictionaryCast(
     const StringFileWriter& file_writer) {
   return reinterpret_cast<const MinidumpSimpleStringDictionary*>(
       &file_writer.string()[0]);
 }
 
 TEST(MinidumpSimpleStringDictionaryWriter, EmptySimpleStringDictionary) {
   StringFileWriter file_writer;
 
   MinidumpSimpleStringDictionaryWriter dictionary_writer;
 
   EXPECT_TRUE(dictionary_writer.WriteEverything(&file_writer));
   ASSERT_EQ(sizeof(MinidumpSimpleStringDictionary),
             file_writer.string().size());
 
   const MinidumpSimpleStringDictionary* dictionary =
       MinidumpSimpleStringDictionaryCast(file_writer);
   EXPECT_EQ(0u, dictionary->count);
 }
 
-std::string MinidumpUTF8StringAtRVA(const StringFileWriter& file_writer,
-                                    RVA rva) {
-  const std::string& contents = file_writer.string();
-  if (rva == 0) {
-    return std::string();
-  }
-
-  if (rva + sizeof(MinidumpUTF8String) > contents.size()) {
-    ADD_FAILURE()
-        << "rva " << rva << " too large for contents " << contents.size();
-    return std::string();
-  }
-
-  const MinidumpUTF8String* minidump_string =
-      reinterpret_cast<const MinidumpUTF8String*>(&contents[rva]);
-
-  // Verify that the file has enough data for the string’s stated length plus
-  // its required NUL terminator.
-  if (rva + sizeof(MinidumpUTF8String) + minidump_string->Length + 1 >
-          contents.size()) {
-    ADD_FAILURE()
-        << "rva " << rva << ", length " << minidump_string->Length
-        << " too large for contents " << contents.size();
-    return std::string();
-  }
-
-  std::string minidump_string_data(
-      reinterpret_cast<const char*>(&minidump_string->Buffer[0]),
-      minidump_string->Length);
-  return minidump_string_data;
-}
-
 TEST(MinidumpSimpleStringDictionaryWriter, EmptyKeyValue) {
   StringFileWriter file_writer;
 
   MinidumpSimpleStringDictionaryWriter dictionary_writer;
   MinidumpSimpleStringDictionaryEntryWriter entry_writer;
   dictionary_writer.AddEntry(&entry_writer);
 
   EXPECT_TRUE(dictionary_writer.WriteEverything(&file_writer));
   ASSERT_EQ(sizeof(MinidumpSimpleStringDictionary) +
                 sizeof(MinidumpSimpleStringDictionaryEntry) +
@@ skipping 126 matching lines @@
   EXPECT_EQ(20u, dictionary->entries[0].value);
   EXPECT_EQ(kKey,
             MinidumpUTF8StringAtRVA(file_writer, dictionary->entries[0].key));
   EXPECT_EQ(kValue1,
             MinidumpUTF8StringAtRVA(file_writer, dictionary->entries[0].value));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad