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 16 matching lines...) Expand all Loading... |
27 #include "base/strings/string16.h" | 27 #include "base/strings/string16.h" |
28 #include "base/strings/stringprintf.h" | 28 #include "base/strings/stringprintf.h" |
29 #include "base/strings/utf_string_conversions.h" | 29 #include "base/strings/utf_string_conversions.h" |
30 #include "gtest/gtest.h" | 30 #include "gtest/gtest.h" |
31 #include "minidump/minidump_file_writer.h" | 31 #include "minidump/minidump_file_writer.h" |
32 #include "minidump/test/minidump_file_writer_test_util.h" | 32 #include "minidump/test/minidump_file_writer_test_util.h" |
33 #include "minidump/test/minidump_writable_test_util.h" | 33 #include "minidump/test/minidump_writable_test_util.h" |
34 #include "snapshot/test/test_process_snapshot.h" | 34 #include "snapshot/test/test_process_snapshot.h" |
35 #include "snapshot/test/test_system_snapshot.h" | 35 #include "snapshot/test/test_system_snapshot.h" |
36 #include "util/file/string_file.h" | 36 #include "util/file/string_file.h" |
| 37 #include "util/misc/arraysize_unsafe.h" |
37 #include "util/stdlib/strlcpy.h" | 38 #include "util/stdlib/strlcpy.h" |
38 | 39 |
39 namespace crashpad { | 40 namespace crashpad { |
40 namespace test { | 41 namespace test { |
41 namespace { | 42 namespace { |
42 | 43 |
43 template <typename T> | 44 template <typename T> |
44 void GetMiscInfoStream(const std::string& file_contents, const T** misc_info) { | 45 void GetMiscInfoStream(const std::string& file_contents, const T** misc_info) { |
45 const size_t kDirectoryOffset = sizeof(MINIDUMP_HEADER); | 46 const size_t kDirectoryOffset = sizeof(MINIDUMP_HEADER); |
46 const size_t kMiscInfoStreamOffset = | 47 const size_t kMiscInfoStreamOffset = |
(...skipping 139 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
186 EXPECT_EQ(expected->XStateData.Features[feature_index].Size, | 187 EXPECT_EQ(expected->XStateData.Features[feature_index].Size, |
187 observed->XStateData.Features[feature_index].Size); | 188 observed->XStateData.Features[feature_index].Size); |
188 } | 189 } |
189 EXPECT_EQ(expected->ProcessCookie, observed->ProcessCookie); | 190 EXPECT_EQ(expected->ProcessCookie, observed->ProcessCookie); |
190 } | 191 } |
191 | 192 |
192 TEST(MinidumpMiscInfoWriter, Empty) { | 193 TEST(MinidumpMiscInfoWriter, Empty) { |
193 MinidumpFileWriter minidump_file_writer; | 194 MinidumpFileWriter minidump_file_writer; |
194 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); | 195 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); |
195 | 196 |
196 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 197 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
197 | 198 |
198 StringFile string_file; | 199 StringFile string_file; |
199 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 200 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
200 | 201 |
201 const MINIDUMP_MISC_INFO* observed = nullptr; | 202 const MINIDUMP_MISC_INFO* observed = nullptr; |
202 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); | 203 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); |
203 | 204 |
204 MINIDUMP_MISC_INFO expected = {}; | 205 MINIDUMP_MISC_INFO expected = {}; |
205 | 206 |
206 ExpectMiscInfoEqual(&expected, observed); | 207 ExpectMiscInfoEqual(&expected, observed); |
207 } | 208 } |
208 | 209 |
209 TEST(MinidumpMiscInfoWriter, ProcessId) { | 210 TEST(MinidumpMiscInfoWriter, ProcessId) { |
210 MinidumpFileWriter minidump_file_writer; | 211 MinidumpFileWriter minidump_file_writer; |
211 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); | 212 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); |
212 | 213 |
213 const uint32_t kProcessId = 12345; | 214 const uint32_t kProcessId = 12345; |
214 | 215 |
215 misc_info_writer->SetProcessID(kProcessId); | 216 misc_info_writer->SetProcessID(kProcessId); |
216 | 217 |
217 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 218 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
218 | 219 |
219 StringFile string_file; | 220 StringFile string_file; |
220 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 221 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
221 | 222 |
222 const MINIDUMP_MISC_INFO* observed = nullptr; | 223 const MINIDUMP_MISC_INFO* observed = nullptr; |
223 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); | 224 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); |
224 | 225 |
225 MINIDUMP_MISC_INFO expected = {}; | 226 MINIDUMP_MISC_INFO expected = {}; |
226 expected.Flags1 = MINIDUMP_MISC1_PROCESS_ID; | 227 expected.Flags1 = MINIDUMP_MISC1_PROCESS_ID; |
227 expected.ProcessId = kProcessId; | 228 expected.ProcessId = kProcessId; |
228 | 229 |
229 ExpectMiscInfoEqual(&expected, observed); | 230 ExpectMiscInfoEqual(&expected, observed); |
230 } | 231 } |
231 | 232 |
232 TEST(MinidumpMiscInfoWriter, ProcessTimes) { | 233 TEST(MinidumpMiscInfoWriter, ProcessTimes) { |
233 MinidumpFileWriter minidump_file_writer; | 234 MinidumpFileWriter minidump_file_writer; |
234 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); | 235 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); |
235 | 236 |
236 const time_t kProcessCreateTime = 0x15252f00; | 237 const time_t kProcessCreateTime = 0x15252f00; |
237 const uint32_t kProcessUserTime = 10; | 238 const uint32_t kProcessUserTime = 10; |
238 const uint32_t kProcessKernelTime = 5; | 239 const uint32_t kProcessKernelTime = 5; |
239 | 240 |
240 misc_info_writer->SetProcessTimes( | 241 misc_info_writer->SetProcessTimes( |
241 kProcessCreateTime, kProcessUserTime, kProcessKernelTime); | 242 kProcessCreateTime, kProcessUserTime, kProcessKernelTime); |
242 | 243 |
243 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 244 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
244 | 245 |
245 StringFile string_file; | 246 StringFile string_file; |
246 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 247 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
247 | 248 |
248 const MINIDUMP_MISC_INFO* observed = nullptr; | 249 const MINIDUMP_MISC_INFO* observed = nullptr; |
249 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); | 250 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); |
250 | 251 |
251 MINIDUMP_MISC_INFO expected = {}; | 252 MINIDUMP_MISC_INFO expected = {}; |
252 expected.Flags1 = MINIDUMP_MISC1_PROCESS_TIMES; | 253 expected.Flags1 = MINIDUMP_MISC1_PROCESS_TIMES; |
253 expected.ProcessCreateTime = kProcessCreateTime; | 254 expected.ProcessCreateTime = kProcessCreateTime; |
(...skipping 12 matching lines...) Expand all Loading... |
266 const uint32_t kProcessorMhzLimit = 3300; | 267 const uint32_t kProcessorMhzLimit = 3300; |
267 const uint32_t kProcessorMaxIdleState = 5; | 268 const uint32_t kProcessorMaxIdleState = 5; |
268 const uint32_t kProcessorCurrentIdleState = 1; | 269 const uint32_t kProcessorCurrentIdleState = 1; |
269 | 270 |
270 misc_info_writer->SetProcessorPowerInfo(kProcessorMaxMhz, | 271 misc_info_writer->SetProcessorPowerInfo(kProcessorMaxMhz, |
271 kProcessorCurrentMhz, | 272 kProcessorCurrentMhz, |
272 kProcessorMhzLimit, | 273 kProcessorMhzLimit, |
273 kProcessorMaxIdleState, | 274 kProcessorMaxIdleState, |
274 kProcessorCurrentIdleState); | 275 kProcessorCurrentIdleState); |
275 | 276 |
276 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 277 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
277 | 278 |
278 StringFile string_file; | 279 StringFile string_file; |
279 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 280 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
280 | 281 |
281 const MINIDUMP_MISC_INFO_2* observed = nullptr; | 282 const MINIDUMP_MISC_INFO_2* observed = nullptr; |
282 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); | 283 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); |
283 | 284 |
284 MINIDUMP_MISC_INFO_2 expected = {}; | 285 MINIDUMP_MISC_INFO_2 expected = {}; |
285 expected.Flags1 = MINIDUMP_MISC1_PROCESSOR_POWER_INFO; | 286 expected.Flags1 = MINIDUMP_MISC1_PROCESSOR_POWER_INFO; |
286 expected.ProcessorMaxMhz = kProcessorMaxMhz; | 287 expected.ProcessorMaxMhz = kProcessorMaxMhz; |
287 expected.ProcessorCurrentMhz = kProcessorCurrentMhz; | 288 expected.ProcessorCurrentMhz = kProcessorCurrentMhz; |
288 expected.ProcessorMhzLimit = kProcessorMhzLimit; | 289 expected.ProcessorMhzLimit = kProcessorMhzLimit; |
289 expected.ProcessorMaxIdleState = kProcessorMaxIdleState; | 290 expected.ProcessorMaxIdleState = kProcessorMaxIdleState; |
290 expected.ProcessorCurrentIdleState = kProcessorCurrentIdleState; | 291 expected.ProcessorCurrentIdleState = kProcessorCurrentIdleState; |
291 | 292 |
292 ExpectMiscInfoEqual(&expected, observed); | 293 ExpectMiscInfoEqual(&expected, observed); |
293 } | 294 } |
294 | 295 |
295 TEST(MinidumpMiscInfoWriter, ProcessIntegrityLevel) { | 296 TEST(MinidumpMiscInfoWriter, ProcessIntegrityLevel) { |
296 MinidumpFileWriter minidump_file_writer; | 297 MinidumpFileWriter minidump_file_writer; |
297 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); | 298 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); |
298 | 299 |
299 const uint32_t kProcessIntegrityLevel = 0x2000; | 300 const uint32_t kProcessIntegrityLevel = 0x2000; |
300 | 301 |
301 misc_info_writer->SetProcessIntegrityLevel(kProcessIntegrityLevel); | 302 misc_info_writer->SetProcessIntegrityLevel(kProcessIntegrityLevel); |
302 | 303 |
303 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 304 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
304 | 305 |
305 StringFile string_file; | 306 StringFile string_file; |
306 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 307 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
307 | 308 |
308 const MINIDUMP_MISC_INFO_3* observed = nullptr; | 309 const MINIDUMP_MISC_INFO_3* observed = nullptr; |
309 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); | 310 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); |
310 | 311 |
311 MINIDUMP_MISC_INFO_3 expected = {}; | 312 MINIDUMP_MISC_INFO_3 expected = {}; |
312 expected.Flags1 = MINIDUMP_MISC3_PROCESS_INTEGRITY; | 313 expected.Flags1 = MINIDUMP_MISC3_PROCESS_INTEGRITY; |
313 expected.ProcessIntegrityLevel = kProcessIntegrityLevel; | 314 expected.ProcessIntegrityLevel = kProcessIntegrityLevel; |
314 | 315 |
315 ExpectMiscInfoEqual(&expected, observed); | 316 ExpectMiscInfoEqual(&expected, observed); |
316 } | 317 } |
317 | 318 |
318 TEST(MinidumpMiscInfoWriter, ProcessExecuteFlags) { | 319 TEST(MinidumpMiscInfoWriter, ProcessExecuteFlags) { |
319 MinidumpFileWriter minidump_file_writer; | 320 MinidumpFileWriter minidump_file_writer; |
320 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); | 321 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); |
321 | 322 |
322 const uint32_t kProcessExecuteFlags = 0x13579bdf; | 323 const uint32_t kProcessExecuteFlags = 0x13579bdf; |
323 | 324 |
324 misc_info_writer->SetProcessExecuteFlags(kProcessExecuteFlags); | 325 misc_info_writer->SetProcessExecuteFlags(kProcessExecuteFlags); |
325 | 326 |
326 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 327 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
327 | 328 |
328 StringFile string_file; | 329 StringFile string_file; |
329 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 330 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
330 | 331 |
331 const MINIDUMP_MISC_INFO_3* observed = nullptr; | 332 const MINIDUMP_MISC_INFO_3* observed = nullptr; |
332 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); | 333 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); |
333 | 334 |
334 MINIDUMP_MISC_INFO_3 expected = {}; | 335 MINIDUMP_MISC_INFO_3 expected = {}; |
335 expected.Flags1 = MINIDUMP_MISC3_PROCESS_EXECUTE_FLAGS; | 336 expected.Flags1 = MINIDUMP_MISC3_PROCESS_EXECUTE_FLAGS; |
336 expected.ProcessExecuteFlags = kProcessExecuteFlags; | 337 expected.ProcessExecuteFlags = kProcessExecuteFlags; |
337 | 338 |
338 ExpectMiscInfoEqual(&expected, observed); | 339 ExpectMiscInfoEqual(&expected, observed); |
339 } | 340 } |
340 | 341 |
341 TEST(MinidumpMiscInfoWriter, ProtectedProcess) { | 342 TEST(MinidumpMiscInfoWriter, ProtectedProcess) { |
342 MinidumpFileWriter minidump_file_writer; | 343 MinidumpFileWriter minidump_file_writer; |
343 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); | 344 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); |
344 | 345 |
345 const uint32_t kProtectedProcess = 1; | 346 const uint32_t kProtectedProcess = 1; |
346 | 347 |
347 misc_info_writer->SetProtectedProcess(kProtectedProcess); | 348 misc_info_writer->SetProtectedProcess(kProtectedProcess); |
348 | 349 |
349 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 350 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
350 | 351 |
351 StringFile string_file; | 352 StringFile string_file; |
352 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 353 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
353 | 354 |
354 const MINIDUMP_MISC_INFO_3* observed = nullptr; | 355 const MINIDUMP_MISC_INFO_3* observed = nullptr; |
355 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); | 356 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); |
356 | 357 |
357 MINIDUMP_MISC_INFO_3 expected = {}; | 358 MINIDUMP_MISC_INFO_3 expected = {}; |
358 expected.Flags1 = MINIDUMP_MISC3_PROTECTED_PROCESS; | 359 expected.Flags1 = MINIDUMP_MISC3_PROTECTED_PROCESS; |
359 expected.ProtectedProcess = kProtectedProcess; | 360 expected.ProtectedProcess = kProtectedProcess; |
(...skipping 16 matching lines...) Expand all Loading... |
376 | 377 |
377 misc_info_writer->SetTimeZone(kTimeZoneId, | 378 misc_info_writer->SetTimeZone(kTimeZoneId, |
378 kBias, | 379 kBias, |
379 kStandardName, | 380 kStandardName, |
380 kStandardDate, | 381 kStandardDate, |
381 kStandardBias, | 382 kStandardBias, |
382 kDaylightName, | 383 kDaylightName, |
383 kDaylightDate, | 384 kDaylightDate, |
384 kDaylightBias); | 385 kDaylightBias); |
385 | 386 |
386 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 387 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
387 | 388 |
388 StringFile string_file; | 389 StringFile string_file; |
389 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 390 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
390 | 391 |
391 const MINIDUMP_MISC_INFO_3* observed = nullptr; | 392 const MINIDUMP_MISC_INFO_3* observed = nullptr; |
392 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); | 393 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); |
393 | 394 |
394 MINIDUMP_MISC_INFO_3 expected = {}; | 395 MINIDUMP_MISC_INFO_3 expected = {}; |
395 expected.Flags1 = MINIDUMP_MISC3_TIMEZONE; | 396 expected.Flags1 = MINIDUMP_MISC3_TIMEZONE; |
396 expected.TimeZoneId = kTimeZoneId; | 397 expected.TimeZoneId = kTimeZoneId; |
397 expected.TimeZone.Bias = kBias; | 398 expected.TimeZone.Bias = kBias; |
398 base::string16 standard_name_utf16 = base::UTF8ToUTF16(kStandardName); | 399 base::string16 standard_name_utf16 = base::UTF8ToUTF16(kStandardName); |
399 c16lcpy(expected.TimeZone.StandardName, | 400 c16lcpy(expected.TimeZone.StandardName, |
400 standard_name_utf16.c_str(), | 401 standard_name_utf16.c_str(), |
401 arraysize(expected.TimeZone.StandardName)); | 402 ARRAYSIZE_UNSAFE(expected.TimeZone.StandardName)); |
402 memcpy(&expected.TimeZone.StandardDate, | 403 memcpy(&expected.TimeZone.StandardDate, |
403 &kStandardDate, | 404 &kStandardDate, |
404 sizeof(expected.TimeZone.StandardDate)); | 405 sizeof(expected.TimeZone.StandardDate)); |
405 expected.TimeZone.StandardBias = kStandardBias; | 406 expected.TimeZone.StandardBias = kStandardBias; |
406 base::string16 daylight_name_utf16 = base::UTF8ToUTF16(kDaylightName); | 407 base::string16 daylight_name_utf16 = base::UTF8ToUTF16(kDaylightName); |
407 c16lcpy(expected.TimeZone.DaylightName, | 408 c16lcpy(expected.TimeZone.DaylightName, |
408 daylight_name_utf16.c_str(), | 409 daylight_name_utf16.c_str(), |
409 arraysize(expected.TimeZone.DaylightName)); | 410 ARRAYSIZE_UNSAFE(expected.TimeZone.DaylightName)); |
410 memcpy(&expected.TimeZone.DaylightDate, | 411 memcpy(&expected.TimeZone.DaylightDate, |
411 &kDaylightDate, | 412 &kDaylightDate, |
412 sizeof(expected.TimeZone.DaylightDate)); | 413 sizeof(expected.TimeZone.DaylightDate)); |
413 expected.TimeZone.DaylightBias = kDaylightBias; | 414 expected.TimeZone.DaylightBias = kDaylightBias; |
414 | 415 |
415 ExpectMiscInfoEqual(&expected, observed); | 416 ExpectMiscInfoEqual(&expected, observed); |
416 } | 417 } |
417 | 418 |
418 TEST(MinidumpMiscInfoWriter, TimeZoneStringsOverflow) { | 419 TEST(MinidumpMiscInfoWriter, TimeZoneStringsOverflow) { |
419 // This test makes sure that the time zone name strings are truncated properly | 420 // This test makes sure that the time zone name strings are truncated properly |
420 // to the widths of their fields. | 421 // to the widths of their fields. |
421 | 422 |
422 MinidumpFileWriter minidump_file_writer; | 423 MinidumpFileWriter minidump_file_writer; |
423 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); | 424 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); |
424 | 425 |
425 const uint32_t kTimeZoneId = 2; | 426 const uint32_t kTimeZoneId = 2; |
426 const int32_t kBias = 300; | 427 const int32_t kBias = 300; |
427 MINIDUMP_MISC_INFO_N tmp; | 428 MINIDUMP_MISC_INFO_N tmp; |
428 ALLOW_UNUSED_LOCAL(tmp); | 429 ALLOW_UNUSED_LOCAL(tmp); |
429 std::string standard_name(arraysize(tmp.TimeZone.StandardName) + 1, 's'); | 430 std::string standard_name(ARRAYSIZE_UNSAFE(tmp.TimeZone.StandardName) + 1, |
| 431 's'); |
430 const int32_t kStandardBias = 0; | 432 const int32_t kStandardBias = 0; |
431 std::string daylight_name(arraysize(tmp.TimeZone.DaylightName), 'd'); | 433 std::string daylight_name(ARRAYSIZE_UNSAFE(tmp.TimeZone.DaylightName), 'd'); |
432 const int32_t kDaylightBias = -60; | 434 const int32_t kDaylightBias = -60; |
433 | 435 |
434 // Test using kSystemTimeZero, because not all platforms will be able to | 436 // Test using kSystemTimeZero, because not all platforms will be able to |
435 // provide daylight saving time transition times. | 437 // provide daylight saving time transition times. |
436 const SYSTEMTIME kSystemTimeZero = {}; | 438 const SYSTEMTIME kSystemTimeZero = {}; |
437 | 439 |
438 misc_info_writer->SetTimeZone(kTimeZoneId, | 440 misc_info_writer->SetTimeZone(kTimeZoneId, |
439 kBias, | 441 kBias, |
440 standard_name, | 442 standard_name, |
441 kSystemTimeZero, | 443 kSystemTimeZero, |
442 kStandardBias, | 444 kStandardBias, |
443 daylight_name, | 445 daylight_name, |
444 kSystemTimeZero, | 446 kSystemTimeZero, |
445 kDaylightBias); | 447 kDaylightBias); |
446 | 448 |
447 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 449 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
448 | 450 |
449 StringFile string_file; | 451 StringFile string_file; |
450 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 452 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
451 | 453 |
452 const MINIDUMP_MISC_INFO_3* observed = nullptr; | 454 const MINIDUMP_MISC_INFO_3* observed = nullptr; |
453 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); | 455 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); |
454 | 456 |
455 MINIDUMP_MISC_INFO_3 expected = {}; | 457 MINIDUMP_MISC_INFO_3 expected = {}; |
456 expected.Flags1 = MINIDUMP_MISC3_TIMEZONE; | 458 expected.Flags1 = MINIDUMP_MISC3_TIMEZONE; |
457 expected.TimeZoneId = kTimeZoneId; | 459 expected.TimeZoneId = kTimeZoneId; |
458 expected.TimeZone.Bias = kBias; | 460 expected.TimeZone.Bias = kBias; |
459 base::string16 standard_name_utf16 = base::UTF8ToUTF16(standard_name); | 461 base::string16 standard_name_utf16 = base::UTF8ToUTF16(standard_name); |
460 c16lcpy(expected.TimeZone.StandardName, | 462 c16lcpy(expected.TimeZone.StandardName, |
461 standard_name_utf16.c_str(), | 463 standard_name_utf16.c_str(), |
462 arraysize(expected.TimeZone.StandardName)); | 464 ARRAYSIZE_UNSAFE(expected.TimeZone.StandardName)); |
463 memcpy(&expected.TimeZone.StandardDate, | 465 memcpy(&expected.TimeZone.StandardDate, |
464 &kSystemTimeZero, | 466 &kSystemTimeZero, |
465 sizeof(expected.TimeZone.StandardDate)); | 467 sizeof(expected.TimeZone.StandardDate)); |
466 expected.TimeZone.StandardBias = kStandardBias; | 468 expected.TimeZone.StandardBias = kStandardBias; |
467 base::string16 daylight_name_utf16 = base::UTF8ToUTF16(daylight_name); | 469 base::string16 daylight_name_utf16 = base::UTF8ToUTF16(daylight_name); |
468 c16lcpy(expected.TimeZone.DaylightName, | 470 c16lcpy(expected.TimeZone.DaylightName, |
469 daylight_name_utf16.c_str(), | 471 daylight_name_utf16.c_str(), |
470 arraysize(expected.TimeZone.DaylightName)); | 472 ARRAYSIZE_UNSAFE(expected.TimeZone.DaylightName)); |
471 memcpy(&expected.TimeZone.DaylightDate, | 473 memcpy(&expected.TimeZone.DaylightDate, |
472 &kSystemTimeZero, | 474 &kSystemTimeZero, |
473 sizeof(expected.TimeZone.DaylightDate)); | 475 sizeof(expected.TimeZone.DaylightDate)); |
474 expected.TimeZone.DaylightBias = kDaylightBias; | 476 expected.TimeZone.DaylightBias = kDaylightBias; |
475 | 477 |
476 ExpectMiscInfoEqual(&expected, observed); | 478 ExpectMiscInfoEqual(&expected, observed); |
477 } | 479 } |
478 | 480 |
479 TEST(MinidumpMiscInfoWriter, BuildStrings) { | 481 TEST(MinidumpMiscInfoWriter, BuildStrings) { |
480 MinidumpFileWriter minidump_file_writer; | 482 MinidumpFileWriter minidump_file_writer; |
481 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); | 483 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); |
482 | 484 |
483 const char kBuildString[] = "build string"; | 485 const char kBuildString[] = "build string"; |
484 const char kDebugBuildString[] = "debug build string"; | 486 const char kDebugBuildString[] = "debug build string"; |
485 | 487 |
486 misc_info_writer->SetBuildString(kBuildString, kDebugBuildString); | 488 misc_info_writer->SetBuildString(kBuildString, kDebugBuildString); |
487 | 489 |
488 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 490 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
489 | 491 |
490 StringFile string_file; | 492 StringFile string_file; |
491 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 493 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
492 | 494 |
493 const MINIDUMP_MISC_INFO_4* observed = nullptr; | 495 const MINIDUMP_MISC_INFO_4* observed = nullptr; |
494 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); | 496 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); |
495 | 497 |
496 MINIDUMP_MISC_INFO_4 expected = {}; | 498 MINIDUMP_MISC_INFO_4 expected = {}; |
497 expected.Flags1 = MINIDUMP_MISC4_BUILDSTRING; | 499 expected.Flags1 = MINIDUMP_MISC4_BUILDSTRING; |
498 base::string16 build_string_utf16 = base::UTF8ToUTF16(kBuildString); | 500 base::string16 build_string_utf16 = base::UTF8ToUTF16(kBuildString); |
499 c16lcpy(expected.BuildString, | 501 c16lcpy(expected.BuildString, |
500 build_string_utf16.c_str(), | 502 build_string_utf16.c_str(), |
501 arraysize(expected.BuildString)); | 503 ARRAYSIZE_UNSAFE(expected.BuildString)); |
502 base::string16 debug_build_string_utf16 = | 504 base::string16 debug_build_string_utf16 = |
503 base::UTF8ToUTF16(kDebugBuildString); | 505 base::UTF8ToUTF16(kDebugBuildString); |
504 c16lcpy(expected.DbgBldStr, | 506 c16lcpy(expected.DbgBldStr, |
505 debug_build_string_utf16.c_str(), | 507 debug_build_string_utf16.c_str(), |
506 arraysize(expected.DbgBldStr)); | 508 ARRAYSIZE_UNSAFE(expected.DbgBldStr)); |
507 | 509 |
508 ExpectMiscInfoEqual(&expected, observed); | 510 ExpectMiscInfoEqual(&expected, observed); |
509 } | 511 } |
510 | 512 |
511 TEST(MinidumpMiscInfoWriter, BuildStringsOverflow) { | 513 TEST(MinidumpMiscInfoWriter, BuildStringsOverflow) { |
512 // This test makes sure that the build strings are truncated properly to the | 514 // This test makes sure that the build strings are truncated properly to the |
513 // widths of their fields. | 515 // widths of their fields. |
514 | 516 |
515 MinidumpFileWriter minidump_file_writer; | 517 MinidumpFileWriter minidump_file_writer; |
516 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); | 518 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); |
517 | 519 |
518 MINIDUMP_MISC_INFO_N tmp; | 520 MINIDUMP_MISC_INFO_N tmp; |
519 ALLOW_UNUSED_LOCAL(tmp); | 521 ALLOW_UNUSED_LOCAL(tmp); |
520 std::string build_string(arraysize(tmp.BuildString) + 1, 'B'); | 522 std::string build_string(ARRAYSIZE_UNSAFE(tmp.BuildString) + 1, 'B'); |
521 std::string debug_build_string(arraysize(tmp.DbgBldStr), 'D'); | 523 std::string debug_build_string(ARRAYSIZE_UNSAFE(tmp.DbgBldStr), 'D'); |
522 | 524 |
523 misc_info_writer->SetBuildString(build_string, debug_build_string); | 525 misc_info_writer->SetBuildString(build_string, debug_build_string); |
524 | 526 |
525 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 527 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
526 | 528 |
527 StringFile string_file; | 529 StringFile string_file; |
528 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 530 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
529 | 531 |
530 const MINIDUMP_MISC_INFO_4* observed = nullptr; | 532 const MINIDUMP_MISC_INFO_4* observed = nullptr; |
531 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); | 533 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); |
532 | 534 |
533 MINIDUMP_MISC_INFO_4 expected = {}; | 535 MINIDUMP_MISC_INFO_4 expected = {}; |
534 expected.Flags1 = MINIDUMP_MISC4_BUILDSTRING; | 536 expected.Flags1 = MINIDUMP_MISC4_BUILDSTRING; |
535 base::string16 build_string_utf16 = base::UTF8ToUTF16(build_string); | 537 base::string16 build_string_utf16 = base::UTF8ToUTF16(build_string); |
536 c16lcpy(expected.BuildString, | 538 c16lcpy(expected.BuildString, |
537 build_string_utf16.c_str(), | 539 build_string_utf16.c_str(), |
538 arraysize(expected.BuildString)); | 540 ARRAYSIZE_UNSAFE(expected.BuildString)); |
539 base::string16 debug_build_string_utf16 = | 541 base::string16 debug_build_string_utf16 = |
540 base::UTF8ToUTF16(debug_build_string); | 542 base::UTF8ToUTF16(debug_build_string); |
541 c16lcpy(expected.DbgBldStr, | 543 c16lcpy(expected.DbgBldStr, |
542 debug_build_string_utf16.c_str(), | 544 debug_build_string_utf16.c_str(), |
543 arraysize(expected.DbgBldStr)); | 545 ARRAYSIZE_UNSAFE(expected.DbgBldStr)); |
544 | 546 |
545 ExpectMiscInfoEqual(&expected, observed); | 547 ExpectMiscInfoEqual(&expected, observed); |
546 } | 548 } |
547 | 549 |
548 TEST(MinidumpMiscInfoWriter, XStateData) { | 550 TEST(MinidumpMiscInfoWriter, XStateData) { |
549 MinidumpFileWriter minidump_file_writer; | 551 MinidumpFileWriter minidump_file_writer; |
550 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); | 552 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); |
551 | 553 |
552 const XSTATE_CONFIG_FEATURE_MSC_INFO kXStateData = { | 554 const XSTATE_CONFIG_FEATURE_MSC_INFO kXStateData = { |
553 sizeof(XSTATE_CONFIG_FEATURE_MSC_INFO), | 555 sizeof(XSTATE_CONFIG_FEATURE_MSC_INFO), |
554 1024, | 556 1024, |
555 0x000000000000005f, | 557 0x000000000000005f, |
556 { | 558 { |
557 {0, 512}, | 559 {0, 512}, |
558 {512, 256}, | 560 {512, 256}, |
559 {768, 128}, | 561 {768, 128}, |
560 {896, 64}, | 562 {896, 64}, |
561 {960, 32}, | 563 {960, 32}, |
562 {0, 0}, | 564 {0, 0}, |
563 {992, 32}, | 565 {992, 32}, |
564 }}; | 566 }}; |
565 | 567 |
566 misc_info_writer->SetXStateData(kXStateData); | 568 misc_info_writer->SetXStateData(kXStateData); |
567 | 569 |
568 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 570 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
569 | 571 |
570 StringFile string_file; | 572 StringFile string_file; |
571 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 573 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
572 | 574 |
573 const MINIDUMP_MISC_INFO_5* observed = nullptr; | 575 const MINIDUMP_MISC_INFO_5* observed = nullptr; |
574 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); | 576 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); |
575 | 577 |
576 MINIDUMP_MISC_INFO_5 expected = {}; | 578 MINIDUMP_MISC_INFO_5 expected = {}; |
577 expected.XStateData = kXStateData; | 579 expected.XStateData = kXStateData; |
578 | 580 |
579 ExpectMiscInfoEqual(&expected, observed); | 581 ExpectMiscInfoEqual(&expected, observed); |
580 } | 582 } |
581 | 583 |
582 TEST(MinidumpMiscInfoWriter, ProcessCookie) { | 584 TEST(MinidumpMiscInfoWriter, ProcessCookie) { |
583 MinidumpFileWriter minidump_file_writer; | 585 MinidumpFileWriter minidump_file_writer; |
584 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); | 586 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); |
585 | 587 |
586 const uint32_t kProcessCookie = 0x12345678; | 588 const uint32_t kProcessCookie = 0x12345678; |
587 | 589 |
588 misc_info_writer->SetProcessCookie(kProcessCookie); | 590 misc_info_writer->SetProcessCookie(kProcessCookie); |
589 | 591 |
590 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 592 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
591 | 593 |
592 StringFile string_file; | 594 StringFile string_file; |
593 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 595 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
594 | 596 |
595 const MINIDUMP_MISC_INFO_5* observed = nullptr; | 597 const MINIDUMP_MISC_INFO_5* observed = nullptr; |
596 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); | 598 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); |
597 | 599 |
598 MINIDUMP_MISC_INFO_5 expected = {}; | 600 MINIDUMP_MISC_INFO_5 expected = {}; |
599 expected.Flags1 = MINIDUMP_MISC5_PROCESS_COOKIE; | 601 expected.Flags1 = MINIDUMP_MISC5_PROCESS_COOKIE; |
600 expected.ProcessCookie = kProcessCookie; | 602 expected.ProcessCookie = kProcessCookie; |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
642 misc_info_writer->SetTimeZone(kTimeZoneId, | 644 misc_info_writer->SetTimeZone(kTimeZoneId, |
643 kBias, | 645 kBias, |
644 kStandardName, | 646 kStandardName, |
645 kSystemTimeZero, | 647 kSystemTimeZero, |
646 kStandardBias, | 648 kStandardBias, |
647 kDaylightName, | 649 kDaylightName, |
648 kSystemTimeZero, | 650 kSystemTimeZero, |
649 kDaylightBias); | 651 kDaylightBias); |
650 misc_info_writer->SetBuildString(kBuildString, kDebugBuildString); | 652 misc_info_writer->SetBuildString(kBuildString, kDebugBuildString); |
651 | 653 |
652 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 654 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
653 | 655 |
654 StringFile string_file; | 656 StringFile string_file; |
655 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 657 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
656 | 658 |
657 const MINIDUMP_MISC_INFO_4* observed = nullptr; | 659 const MINIDUMP_MISC_INFO_4* observed = nullptr; |
658 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); | 660 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &observed)); |
659 | 661 |
660 MINIDUMP_MISC_INFO_4 expected = {}; | 662 MINIDUMP_MISC_INFO_4 expected = {}; |
661 expected.Flags1 = | 663 expected.Flags1 = |
662 MINIDUMP_MISC1_PROCESS_ID | MINIDUMP_MISC1_PROCESS_TIMES | | 664 MINIDUMP_MISC1_PROCESS_ID | MINIDUMP_MISC1_PROCESS_TIMES | |
(...skipping 10 matching lines...) Expand all Loading... |
673 expected.ProcessorMaxIdleState = kProcessorMaxIdleState; | 675 expected.ProcessorMaxIdleState = kProcessorMaxIdleState; |
674 expected.ProcessorCurrentIdleState = kProcessorCurrentIdleState; | 676 expected.ProcessorCurrentIdleState = kProcessorCurrentIdleState; |
675 expected.ProcessIntegrityLevel = kProcessIntegrityLevel; | 677 expected.ProcessIntegrityLevel = kProcessIntegrityLevel; |
676 expected.ProcessExecuteFlags = kProcessExecuteFlags; | 678 expected.ProcessExecuteFlags = kProcessExecuteFlags; |
677 expected.ProtectedProcess = kProtectedProcess; | 679 expected.ProtectedProcess = kProtectedProcess; |
678 expected.TimeZoneId = kTimeZoneId; | 680 expected.TimeZoneId = kTimeZoneId; |
679 expected.TimeZone.Bias = kBias; | 681 expected.TimeZone.Bias = kBias; |
680 base::string16 standard_name_utf16 = base::UTF8ToUTF16(kStandardName); | 682 base::string16 standard_name_utf16 = base::UTF8ToUTF16(kStandardName); |
681 c16lcpy(expected.TimeZone.StandardName, | 683 c16lcpy(expected.TimeZone.StandardName, |
682 standard_name_utf16.c_str(), | 684 standard_name_utf16.c_str(), |
683 arraysize(expected.TimeZone.StandardName)); | 685 ARRAYSIZE_UNSAFE(expected.TimeZone.StandardName)); |
684 memcpy(&expected.TimeZone.StandardDate, | 686 memcpy(&expected.TimeZone.StandardDate, |
685 &kSystemTimeZero, | 687 &kSystemTimeZero, |
686 sizeof(expected.TimeZone.StandardDate)); | 688 sizeof(expected.TimeZone.StandardDate)); |
687 expected.TimeZone.StandardBias = kStandardBias; | 689 expected.TimeZone.StandardBias = kStandardBias; |
688 base::string16 daylight_name_utf16 = base::UTF8ToUTF16(kDaylightName); | 690 base::string16 daylight_name_utf16 = base::UTF8ToUTF16(kDaylightName); |
689 c16lcpy(expected.TimeZone.DaylightName, | 691 c16lcpy(expected.TimeZone.DaylightName, |
690 daylight_name_utf16.c_str(), | 692 daylight_name_utf16.c_str(), |
691 arraysize(expected.TimeZone.DaylightName)); | 693 ARRAYSIZE_UNSAFE(expected.TimeZone.DaylightName)); |
692 memcpy(&expected.TimeZone.DaylightDate, | 694 memcpy(&expected.TimeZone.DaylightDate, |
693 &kSystemTimeZero, | 695 &kSystemTimeZero, |
694 sizeof(expected.TimeZone.DaylightDate)); | 696 sizeof(expected.TimeZone.DaylightDate)); |
695 expected.TimeZone.DaylightBias = kDaylightBias; | 697 expected.TimeZone.DaylightBias = kDaylightBias; |
696 base::string16 build_string_utf16 = base::UTF8ToUTF16(kBuildString); | 698 base::string16 build_string_utf16 = base::UTF8ToUTF16(kBuildString); |
697 c16lcpy(expected.BuildString, | 699 c16lcpy(expected.BuildString, |
698 build_string_utf16.c_str(), | 700 build_string_utf16.c_str(), |
699 arraysize(expected.BuildString)); | 701 ARRAYSIZE_UNSAFE(expected.BuildString)); |
700 base::string16 debug_build_string_utf16 = | 702 base::string16 debug_build_string_utf16 = |
701 base::UTF8ToUTF16(kDebugBuildString); | 703 base::UTF8ToUTF16(kDebugBuildString); |
702 c16lcpy(expected.DbgBldStr, | 704 c16lcpy(expected.DbgBldStr, |
703 debug_build_string_utf16.c_str(), | 705 debug_build_string_utf16.c_str(), |
704 arraysize(expected.DbgBldStr)); | 706 ARRAYSIZE_UNSAFE(expected.DbgBldStr)); |
705 | 707 |
706 ExpectMiscInfoEqual(&expected, observed); | 708 ExpectMiscInfoEqual(&expected, observed); |
707 } | 709 } |
708 | 710 |
709 TEST(MinidumpMiscInfoWriter, InitializeFromSnapshot) { | 711 TEST(MinidumpMiscInfoWriter, InitializeFromSnapshot) { |
710 MINIDUMP_MISC_INFO_4 expect_misc_info = {}; | 712 MINIDUMP_MISC_INFO_4 expect_misc_info = {}; |
711 | 713 |
712 const char kStandardTimeName[] = "EST"; | 714 const char kStandardTimeName[] = "EST"; |
713 const char kDaylightTimeName[] = "EDT"; | 715 const char kDaylightTimeName[] = "EDT"; |
714 const char kOSVersionFull[] = | 716 const char kOSVersionFull[] = |
(...skipping 22 matching lines...) Expand all Loading... |
737 expect_misc_info.ProcessId = 12345; | 739 expect_misc_info.ProcessId = 12345; |
738 expect_misc_info.ProcessCreateTime = 0x555c7740; | 740 expect_misc_info.ProcessCreateTime = 0x555c7740; |
739 expect_misc_info.ProcessUserTime = 60; | 741 expect_misc_info.ProcessUserTime = 60; |
740 expect_misc_info.ProcessKernelTime = 15; | 742 expect_misc_info.ProcessKernelTime = 15; |
741 expect_misc_info.ProcessorCurrentMhz = 2800; | 743 expect_misc_info.ProcessorCurrentMhz = 2800; |
742 expect_misc_info.ProcessorMaxMhz = 2800; | 744 expect_misc_info.ProcessorMaxMhz = 2800; |
743 expect_misc_info.TimeZoneId = 1; | 745 expect_misc_info.TimeZoneId = 1; |
744 expect_misc_info.TimeZone.Bias = 300; | 746 expect_misc_info.TimeZone.Bias = 300; |
745 c16lcpy(expect_misc_info.TimeZone.StandardName, | 747 c16lcpy(expect_misc_info.TimeZone.StandardName, |
746 standard_time_name_utf16.c_str(), | 748 standard_time_name_utf16.c_str(), |
747 arraysize(expect_misc_info.TimeZone.StandardName)); | 749 ARRAYSIZE_UNSAFE(expect_misc_info.TimeZone.StandardName)); |
748 expect_misc_info.TimeZone.StandardBias = 0; | 750 expect_misc_info.TimeZone.StandardBias = 0; |
749 c16lcpy(expect_misc_info.TimeZone.DaylightName, | 751 c16lcpy(expect_misc_info.TimeZone.DaylightName, |
750 daylight_time_name_utf16.c_str(), | 752 daylight_time_name_utf16.c_str(), |
751 arraysize(expect_misc_info.TimeZone.DaylightName)); | 753 ARRAYSIZE_UNSAFE(expect_misc_info.TimeZone.DaylightName)); |
752 expect_misc_info.TimeZone.DaylightBias = -60; | 754 expect_misc_info.TimeZone.DaylightBias = -60; |
753 c16lcpy(expect_misc_info.BuildString, | 755 c16lcpy(expect_misc_info.BuildString, |
754 build_string_utf16.c_str(), | 756 build_string_utf16.c_str(), |
755 arraysize(expect_misc_info.BuildString)); | 757 ARRAYSIZE_UNSAFE(expect_misc_info.BuildString)); |
756 c16lcpy(expect_misc_info.DbgBldStr, | 758 c16lcpy(expect_misc_info.DbgBldStr, |
757 debug_build_string_utf16.c_str(), | 759 debug_build_string_utf16.c_str(), |
758 arraysize(expect_misc_info.DbgBldStr)); | 760 ARRAYSIZE_UNSAFE(expect_misc_info.DbgBldStr)); |
759 | 761 |
760 const timeval kStartTime = | 762 const timeval kStartTime = |
761 { static_cast<time_t>(expect_misc_info.ProcessCreateTime), 0 }; | 763 { static_cast<time_t>(expect_misc_info.ProcessCreateTime), 0 }; |
762 const timeval kUserCPUTime = | 764 const timeval kUserCPUTime = |
763 { static_cast<time_t>(expect_misc_info.ProcessUserTime), 0 }; | 765 { static_cast<time_t>(expect_misc_info.ProcessUserTime), 0 }; |
764 const timeval kSystemCPUTime = | 766 const timeval kSystemCPUTime = |
765 { static_cast<time_t>(expect_misc_info.ProcessKernelTime), 0 }; | 767 { static_cast<time_t>(expect_misc_info.ProcessKernelTime), 0 }; |
766 | 768 |
767 TestProcessSnapshot process_snapshot; | 769 TestProcessSnapshot process_snapshot; |
768 process_snapshot.SetProcessID(expect_misc_info.ProcessId); | 770 process_snapshot.SetProcessID(expect_misc_info.ProcessId); |
(...skipping 13 matching lines...) Expand all Loading... |
782 kDaylightTimeName); | 784 kDaylightTimeName); |
783 system_snapshot->SetOSVersionFull(kOSVersionFull); | 785 system_snapshot->SetOSVersionFull(kOSVersionFull); |
784 system_snapshot->SetMachineDescription(kMachineDescription); | 786 system_snapshot->SetMachineDescription(kMachineDescription); |
785 | 787 |
786 process_snapshot.SetSystem(std::move(system_snapshot)); | 788 process_snapshot.SetSystem(std::move(system_snapshot)); |
787 | 789 |
788 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); | 790 auto misc_info_writer = base::WrapUnique(new MinidumpMiscInfoWriter()); |
789 misc_info_writer->InitializeFromSnapshot(&process_snapshot); | 791 misc_info_writer->InitializeFromSnapshot(&process_snapshot); |
790 | 792 |
791 MinidumpFileWriter minidump_file_writer; | 793 MinidumpFileWriter minidump_file_writer; |
792 minidump_file_writer.AddStream(std::move(misc_info_writer)); | 794 ASSERT_TRUE(minidump_file_writer.AddStream(std::move(misc_info_writer))); |
793 | 795 |
794 StringFile string_file; | 796 StringFile string_file; |
795 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); | 797 ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file)); |
796 | 798 |
797 const MINIDUMP_MISC_INFO_4* misc_info = nullptr; | 799 const MINIDUMP_MISC_INFO_4* misc_info = nullptr; |
798 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &misc_info)); | 800 ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(string_file.string(), &misc_info)); |
799 | 801 |
800 ExpectMiscInfoEqual(&expect_misc_info, misc_info); | 802 ExpectMiscInfoEqual(&expect_misc_info, misc_info); |
801 } | 803 } |
802 | 804 |
803 } // namespace | 805 } // namespace |
804 } // namespace test | 806 } // namespace test |
805 } // namespace crashpad | 807 } // namespace crashpad |
OLD | NEW |