OLD | NEW |
1 // Copyright 2014 The Crashpad Authors. All rights reserved. | 1 // Copyright 2014 The Crashpad Authors. All rights reserved. |
2 // | 2 // |
3 // Licensed under the Apache License, Version 2.0 (the "License"); | 3 // Licensed under the Apache License, Version 2.0 (the "License"); |
4 // you may not use this file except in compliance with the License. | 4 // you may not use this file except in compliance with the License. |
5 // You may obtain a copy of the License at | 5 // You may obtain a copy of the License at |
6 // | 6 // |
7 // http://www.apache.org/licenses/LICENSE-2.0 | 7 // http://www.apache.org/licenses/LICENSE-2.0 |
8 // | 8 // |
9 // Unless required by applicable law or agreed to in writing, software | 9 // Unless required by applicable law or agreed to in writing, software |
10 // distributed under the License is distributed on an "AS IS" BASIS, | 10 // distributed under the License is distributed on an "AS IS" BASIS, |
(...skipping 12 matching lines...) Expand all Loading... |
23 #include "gtest/gtest.h" | 23 #include "gtest/gtest.h" |
24 #include "minidump/minidump_extensions.h" | 24 #include "minidump/minidump_extensions.h" |
25 #include "minidump/minidump_file_writer.h" | 25 #include "minidump/minidump_file_writer.h" |
26 #include "minidump/minidump_module_crashpad_info_writer.h" | 26 #include "minidump/minidump_module_crashpad_info_writer.h" |
27 #include "minidump/minidump_simple_string_dictionary_writer.h" | 27 #include "minidump/minidump_simple_string_dictionary_writer.h" |
28 #include "minidump/test/minidump_file_writer_test_util.h" | 28 #include "minidump/test/minidump_file_writer_test_util.h" |
29 #include "minidump/test/minidump_string_writer_test_util.h" | 29 #include "minidump/test/minidump_string_writer_test_util.h" |
30 #include "minidump/test/minidump_writable_test_util.h" | 30 #include "minidump/test/minidump_writable_test_util.h" |
31 #include "snapshot/test/test_module_snapshot.h" | 31 #include "snapshot/test/test_module_snapshot.h" |
32 #include "snapshot/test/test_process_snapshot.h" | 32 #include "snapshot/test/test_process_snapshot.h" |
33 #include "util/file/string_file_writer.h" | 33 #include "util/file/string_file.h" |
34 | 34 |
35 namespace crashpad { | 35 namespace crashpad { |
36 namespace test { | 36 namespace test { |
37 namespace { | 37 namespace { |
38 | 38 |
39 void GetCrashpadInfoStream( | 39 void GetCrashpadInfoStream( |
40 const std::string& file_contents, | 40 const std::string& file_contents, |
41 const MinidumpCrashpadInfo** crashpad_info, | 41 const MinidumpCrashpadInfo** crashpad_info, |
42 const MinidumpSimpleStringDictionary** simple_annotations, | 42 const MinidumpSimpleStringDictionary** simple_annotations, |
43 const MinidumpModuleCrashpadInfoList** module_list) { | 43 const MinidumpModuleCrashpadInfoList** module_list) { |
(...skipping 18 matching lines...) Expand all Loading... |
62 file_contents, (*crashpad_info)->module_list); | 62 file_contents, (*crashpad_info)->module_list); |
63 } | 63 } |
64 | 64 |
65 TEST(MinidumpCrashpadInfoWriter, Empty) { | 65 TEST(MinidumpCrashpadInfoWriter, Empty) { |
66 MinidumpFileWriter minidump_file_writer; | 66 MinidumpFileWriter minidump_file_writer; |
67 auto crashpad_info_writer = make_scoped_ptr(new MinidumpCrashpadInfoWriter()); | 67 auto crashpad_info_writer = make_scoped_ptr(new MinidumpCrashpadInfoWriter()); |
68 EXPECT_FALSE(crashpad_info_writer->IsUseful()); | 68 EXPECT_FALSE(crashpad_info_writer->IsUseful()); |
69 | 69 |
70 minidump_file_writer.AddStream(crashpad_info_writer.Pass()); | 70 minidump_file_writer.AddStream(crashpad_info_writer.Pass()); |
71 | 71 |
72 StringFileWriter file_writer; | 72 StringFile string_file; |
73 ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer)); | 73 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
74 | 74 |
75 const MinidumpCrashpadInfo* crashpad_info = nullptr; | 75 const MinidumpCrashpadInfo* crashpad_info = nullptr; |
76 const MinidumpSimpleStringDictionary* simple_annotations = nullptr; | 76 const MinidumpSimpleStringDictionary* simple_annotations = nullptr; |
77 const MinidumpModuleCrashpadInfoList* module_list = nullptr; | 77 const MinidumpModuleCrashpadInfoList* module_list = nullptr; |
78 | 78 |
79 ASSERT_NO_FATAL_FAILURE(GetCrashpadInfoStream( | 79 ASSERT_NO_FATAL_FAILURE(GetCrashpadInfoStream( |
80 file_writer.string(), &crashpad_info, &simple_annotations, &module_list)); | 80 string_file.string(), &crashpad_info, &simple_annotations, &module_list)); |
81 | 81 |
82 EXPECT_EQ(MinidumpCrashpadInfo::kVersion, crashpad_info->version); | 82 EXPECT_EQ(MinidumpCrashpadInfo::kVersion, crashpad_info->version); |
83 EXPECT_FALSE(simple_annotations); | 83 EXPECT_FALSE(simple_annotations); |
84 EXPECT_FALSE(module_list); | 84 EXPECT_FALSE(module_list); |
85 } | 85 } |
86 | 86 |
87 TEST(MinidumpCrashpadInfoWriter, SimpleAnnotations) { | 87 TEST(MinidumpCrashpadInfoWriter, SimpleAnnotations) { |
88 MinidumpFileWriter minidump_file_writer; | 88 MinidumpFileWriter minidump_file_writer; |
89 auto crashpad_info_writer = make_scoped_ptr(new MinidumpCrashpadInfoWriter()); | 89 auto crashpad_info_writer = make_scoped_ptr(new MinidumpCrashpadInfoWriter()); |
90 | 90 |
(...skipping 10 matching lines...) Expand all Loading... |
101 simple_string_dictionary_entry_writer->SetKeyValue(kKey, kValue); | 101 simple_string_dictionary_entry_writer->SetKeyValue(kKey, kValue); |
102 simple_string_dictionary_writer->AddEntry( | 102 simple_string_dictionary_writer->AddEntry( |
103 simple_string_dictionary_entry_writer.Pass()); | 103 simple_string_dictionary_entry_writer.Pass()); |
104 crashpad_info_writer->SetSimpleAnnotations( | 104 crashpad_info_writer->SetSimpleAnnotations( |
105 simple_string_dictionary_writer.Pass()); | 105 simple_string_dictionary_writer.Pass()); |
106 | 106 |
107 EXPECT_TRUE(crashpad_info_writer->IsUseful()); | 107 EXPECT_TRUE(crashpad_info_writer->IsUseful()); |
108 | 108 |
109 minidump_file_writer.AddStream(crashpad_info_writer.Pass()); | 109 minidump_file_writer.AddStream(crashpad_info_writer.Pass()); |
110 | 110 |
111 StringFileWriter file_writer; | 111 StringFile string_file; |
112 ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer)); | 112 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
113 | 113 |
114 const MinidumpCrashpadInfo* crashpad_info = nullptr; | 114 const MinidumpCrashpadInfo* crashpad_info = nullptr; |
115 const MinidumpSimpleStringDictionary* simple_annotations = nullptr; | 115 const MinidumpSimpleStringDictionary* simple_annotations = nullptr; |
116 const MinidumpModuleCrashpadInfoList* module_list = nullptr; | 116 const MinidumpModuleCrashpadInfoList* module_list = nullptr; |
117 | 117 |
118 ASSERT_NO_FATAL_FAILURE(GetCrashpadInfoStream( | 118 ASSERT_NO_FATAL_FAILURE(GetCrashpadInfoStream( |
119 file_writer.string(), &crashpad_info, &simple_annotations, &module_list)); | 119 string_file.string(), &crashpad_info, &simple_annotations, &module_list)); |
120 | 120 |
121 EXPECT_EQ(MinidumpCrashpadInfo::kVersion, crashpad_info->version); | 121 EXPECT_EQ(MinidumpCrashpadInfo::kVersion, crashpad_info->version); |
122 EXPECT_FALSE(module_list); | 122 EXPECT_FALSE(module_list); |
123 | 123 |
124 ASSERT_TRUE(simple_annotations); | 124 ASSERT_TRUE(simple_annotations); |
125 ASSERT_EQ(1u, simple_annotations->count); | 125 ASSERT_EQ(1u, simple_annotations->count); |
126 EXPECT_EQ(kKey, | 126 EXPECT_EQ(kKey, |
127 MinidumpUTF8StringAtRVAAsString( | 127 MinidumpUTF8StringAtRVAAsString( |
128 file_writer.string(), simple_annotations->entries[0].key)); | 128 string_file.string(), simple_annotations->entries[0].key)); |
129 EXPECT_EQ(kValue, | 129 EXPECT_EQ(kValue, |
130 MinidumpUTF8StringAtRVAAsString( | 130 MinidumpUTF8StringAtRVAAsString( |
131 file_writer.string(), simple_annotations->entries[0].value)); | 131 string_file.string(), simple_annotations->entries[0].value)); |
132 } | 132 } |
133 | 133 |
134 TEST(MinidumpCrashpadInfoWriter, CrashpadModuleList) { | 134 TEST(MinidumpCrashpadInfoWriter, CrashpadModuleList) { |
135 const uint32_t kMinidumpModuleListIndex = 3; | 135 const uint32_t kMinidumpModuleListIndex = 3; |
136 | 136 |
137 MinidumpFileWriter minidump_file_writer; | 137 MinidumpFileWriter minidump_file_writer; |
138 auto crashpad_info_writer = make_scoped_ptr(new MinidumpCrashpadInfoWriter()); | 138 auto crashpad_info_writer = make_scoped_ptr(new MinidumpCrashpadInfoWriter()); |
139 | 139 |
140 auto module_list_writer = | 140 auto module_list_writer = |
141 make_scoped_ptr(new MinidumpModuleCrashpadInfoListWriter()); | 141 make_scoped_ptr(new MinidumpModuleCrashpadInfoListWriter()); |
142 auto module_writer = make_scoped_ptr(new MinidumpModuleCrashpadInfoWriter()); | 142 auto module_writer = make_scoped_ptr(new MinidumpModuleCrashpadInfoWriter()); |
143 module_writer->SetMinidumpModuleListIndex(kMinidumpModuleListIndex); | 143 module_writer->SetMinidumpModuleListIndex(kMinidumpModuleListIndex); |
144 module_list_writer->AddModule(module_writer.Pass()); | 144 module_list_writer->AddModule(module_writer.Pass()); |
145 crashpad_info_writer->SetModuleList(module_list_writer.Pass()); | 145 crashpad_info_writer->SetModuleList(module_list_writer.Pass()); |
146 | 146 |
147 EXPECT_TRUE(crashpad_info_writer->IsUseful()); | 147 EXPECT_TRUE(crashpad_info_writer->IsUseful()); |
148 | 148 |
149 minidump_file_writer.AddStream(crashpad_info_writer.Pass()); | 149 minidump_file_writer.AddStream(crashpad_info_writer.Pass()); |
150 | 150 |
151 StringFileWriter file_writer; | 151 StringFile string_file; |
152 ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer)); | 152 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
153 | 153 |
154 const MinidumpCrashpadInfo* crashpad_info = nullptr; | 154 const MinidumpCrashpadInfo* crashpad_info = nullptr; |
155 const MinidumpSimpleStringDictionary* simple_annotations = nullptr; | 155 const MinidumpSimpleStringDictionary* simple_annotations = nullptr; |
156 const MinidumpModuleCrashpadInfoList* module_list = nullptr; | 156 const MinidumpModuleCrashpadInfoList* module_list = nullptr; |
157 | 157 |
158 ASSERT_NO_FATAL_FAILURE(GetCrashpadInfoStream( | 158 ASSERT_NO_FATAL_FAILURE(GetCrashpadInfoStream( |
159 file_writer.string(), &crashpad_info, &simple_annotations, &module_list)); | 159 string_file.string(), &crashpad_info, &simple_annotations, &module_list)); |
160 | 160 |
161 EXPECT_EQ(MinidumpCrashpadInfo::kVersion, crashpad_info->version); | 161 EXPECT_EQ(MinidumpCrashpadInfo::kVersion, crashpad_info->version); |
162 EXPECT_FALSE(simple_annotations); | 162 EXPECT_FALSE(simple_annotations); |
163 | 163 |
164 ASSERT_TRUE(module_list); | 164 ASSERT_TRUE(module_list); |
165 ASSERT_EQ(1u, module_list->count); | 165 ASSERT_EQ(1u, module_list->count); |
166 | 166 |
167 const MinidumpModuleCrashpadInfo* module = | 167 const MinidumpModuleCrashpadInfo* module = |
168 MinidumpWritableAtLocationDescriptor<MinidumpModuleCrashpadInfo>( | 168 MinidumpWritableAtLocationDescriptor<MinidumpModuleCrashpadInfo>( |
169 file_writer.string(), module_list->children[0]); | 169 string_file.string(), module_list->children[0]); |
170 ASSERT_TRUE(module); | 170 ASSERT_TRUE(module); |
171 | 171 |
172 EXPECT_EQ(MinidumpModuleCrashpadInfo::kVersion, module->version); | 172 EXPECT_EQ(MinidumpModuleCrashpadInfo::kVersion, module->version); |
173 EXPECT_EQ(kMinidumpModuleListIndex, module->minidump_module_list_index); | 173 EXPECT_EQ(kMinidumpModuleListIndex, module->minidump_module_list_index); |
174 EXPECT_EQ(0u, module->list_annotations.DataSize); | 174 EXPECT_EQ(0u, module->list_annotations.DataSize); |
175 EXPECT_EQ(0u, module->list_annotations.Rva); | 175 EXPECT_EQ(0u, module->list_annotations.Rva); |
176 EXPECT_EQ(0u, module->simple_annotations.DataSize); | 176 EXPECT_EQ(0u, module->simple_annotations.DataSize); |
177 EXPECT_EQ(0u, module->simple_annotations.Rva); | 177 EXPECT_EQ(0u, module->simple_annotations.Rva); |
178 } | 178 } |
179 | 179 |
(...skipping 25 matching lines...) Expand all Loading... |
205 module_snapshot->SetAnnotationsVector(annotations_list); | 205 module_snapshot->SetAnnotationsVector(annotations_list); |
206 process_snapshot->AddModule(module_snapshot.Pass()); | 206 process_snapshot->AddModule(module_snapshot.Pass()); |
207 | 207 |
208 info_writer.reset(new MinidumpCrashpadInfoWriter()); | 208 info_writer.reset(new MinidumpCrashpadInfoWriter()); |
209 info_writer->InitializeFromSnapshot(process_snapshot.get()); | 209 info_writer->InitializeFromSnapshot(process_snapshot.get()); |
210 EXPECT_TRUE(info_writer->IsUseful()); | 210 EXPECT_TRUE(info_writer->IsUseful()); |
211 | 211 |
212 MinidumpFileWriter minidump_file_writer; | 212 MinidumpFileWriter minidump_file_writer; |
213 minidump_file_writer.AddStream(info_writer.Pass()); | 213 minidump_file_writer.AddStream(info_writer.Pass()); |
214 | 214 |
215 StringFileWriter file_writer; | 215 StringFile string_file; |
216 ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer)); | 216 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
217 | 217 |
218 const MinidumpCrashpadInfo* info = nullptr; | 218 const MinidumpCrashpadInfo* info = nullptr; |
219 const MinidumpSimpleStringDictionary* simple_annotations; | 219 const MinidumpSimpleStringDictionary* simple_annotations; |
220 const MinidumpModuleCrashpadInfoList* module_list; | 220 const MinidumpModuleCrashpadInfoList* module_list; |
221 ASSERT_NO_FATAL_FAILURE(GetCrashpadInfoStream( | 221 ASSERT_NO_FATAL_FAILURE(GetCrashpadInfoStream( |
222 file_writer.string(), &info, &simple_annotations, &module_list)); | 222 string_file.string(), &info, &simple_annotations, &module_list)); |
223 | 223 |
224 EXPECT_EQ(MinidumpCrashpadInfo::kVersion, info->version); | 224 EXPECT_EQ(MinidumpCrashpadInfo::kVersion, info->version); |
225 | 225 |
226 ASSERT_TRUE(simple_annotations); | 226 ASSERT_TRUE(simple_annotations); |
227 ASSERT_EQ(1u, simple_annotations->count); | 227 ASSERT_EQ(1u, simple_annotations->count); |
228 EXPECT_EQ(kKey, | 228 EXPECT_EQ(kKey, |
229 MinidumpUTF8StringAtRVAAsString( | 229 MinidumpUTF8StringAtRVAAsString( |
230 file_writer.string(), simple_annotations->entries[0].key)); | 230 string_file.string(), simple_annotations->entries[0].key)); |
231 EXPECT_EQ(kValue, | 231 EXPECT_EQ(kValue, |
232 MinidumpUTF8StringAtRVAAsString( | 232 MinidumpUTF8StringAtRVAAsString( |
233 file_writer.string(), simple_annotations->entries[0].value)); | 233 string_file.string(), simple_annotations->entries[0].value)); |
234 | 234 |
235 ASSERT_TRUE(module_list); | 235 ASSERT_TRUE(module_list); |
236 ASSERT_EQ(1u, module_list->count); | 236 ASSERT_EQ(1u, module_list->count); |
237 | 237 |
238 const MinidumpModuleCrashpadInfo* module = | 238 const MinidumpModuleCrashpadInfo* module = |
239 MinidumpWritableAtLocationDescriptor<MinidumpModuleCrashpadInfo>( | 239 MinidumpWritableAtLocationDescriptor<MinidumpModuleCrashpadInfo>( |
240 file_writer.string(), module_list->children[0]); | 240 string_file.string(), module_list->children[0]); |
241 ASSERT_TRUE(module); | 241 ASSERT_TRUE(module); |
242 | 242 |
243 EXPECT_EQ(MinidumpModuleCrashpadInfo::kVersion, module->version); | 243 EXPECT_EQ(MinidumpModuleCrashpadInfo::kVersion, module->version); |
244 EXPECT_EQ(0u, module->minidump_module_list_index); | 244 EXPECT_EQ(0u, module->minidump_module_list_index); |
245 | 245 |
246 const MinidumpRVAList* list_annotations = | 246 const MinidumpRVAList* list_annotations = |
247 MinidumpWritableAtLocationDescriptor<MinidumpRVAList>( | 247 MinidumpWritableAtLocationDescriptor<MinidumpRVAList>( |
248 file_writer.string(), module->list_annotations); | 248 string_file.string(), module->list_annotations); |
249 ASSERT_TRUE(list_annotations); | 249 ASSERT_TRUE(list_annotations); |
250 | 250 |
251 ASSERT_EQ(1u, list_annotations->count); | 251 ASSERT_EQ(1u, list_annotations->count); |
252 EXPECT_EQ(kEntry, | 252 EXPECT_EQ(kEntry, |
253 MinidumpUTF8StringAtRVAAsString(file_writer.string(), | 253 MinidumpUTF8StringAtRVAAsString(string_file.string(), |
254 list_annotations->children[0])); | 254 list_annotations->children[0])); |
255 | 255 |
256 const MinidumpSimpleStringDictionary* module_simple_annotations = | 256 const MinidumpSimpleStringDictionary* module_simple_annotations = |
257 MinidumpWritableAtLocationDescriptor<MinidumpSimpleStringDictionary>( | 257 MinidumpWritableAtLocationDescriptor<MinidumpSimpleStringDictionary>( |
258 file_writer.string(), module->simple_annotations); | 258 string_file.string(), module->simple_annotations); |
259 EXPECT_FALSE(module_simple_annotations); | 259 EXPECT_FALSE(module_simple_annotations); |
260 } | 260 } |
261 | 261 |
262 } // namespace | 262 } // namespace |
263 } // namespace test | 263 } // namespace test |
264 } // namespace crashpad | 264 } // namespace crashpad |
OLD | NEW |