llvm/unittests/ObjectYAML/MinidumpYAMLTest.cpp - rust-lang/llvm-project - Git at Google

 //===- MinidumpYAMLTest.cpp - Tests for Minidump<->YAML code --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #include "llvm/Object/Minidump.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"

 using namespace llvm;
 using namespace llvm::minidump;

 static Expected<std::unique_ptr<object::MinidumpFile>>
 toBinary(SmallVectorImpl<char> &Storage, StringRef Yaml) {
   Storage.clear();
   raw_svector_ostream OS(Storage);
   yaml::Input YIn(Yaml);
   if (!yaml::convertYAML(YIn, OS, [](const Twine &Msg) {}))
     return createStringError(std::errc::invalid_argument,
                              "unable to convert YAML");

   return object::MinidumpFile::create(MemoryBufferRef(OS.str(), "Binary"));
 }

 TEST(MinidumpYAML, Basic) {
   SmallString<0> Storage;
   auto ExpectedFile = toBinary(Storage, R"(
 --- !minidump
 Streams:
   - Type:            SystemInfo
     Processor Arch:  ARM64
     Platform ID:     Linux
     CPU:
       CPUID:           0x05060708
   - Type:            LinuxMaps
     Text:             |
       400d9000-400db000 r-xp 00000000 b3:04 227        /system/bin/app_process
       400db000-400dc000 r--p 00001000 b3:04 227        /system/bin/app_process

   - Type:            LinuxAuxv
     Content:         DEADBEEFBAADF00D)");
   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
   object::MinidumpFile &File = **ExpectedFile;

   ASSERT_EQ(3u, File.streams().size());

   EXPECT_EQ(StreamType::SystemInfo, File.streams()[0].Type);
   auto ExpectedSysInfo = File.getSystemInfo();
   ASSERT_THAT_EXPECTED(ExpectedSysInfo, Succeeded());
   const SystemInfo &SysInfo = *ExpectedSysInfo;
   EXPECT_EQ(ProcessorArchitecture::ARM64, SysInfo.ProcessorArch);
   EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
   EXPECT_EQ(0x05060708u, SysInfo.CPU.Arm.CPUID);

   EXPECT_EQ(StreamType::LinuxMaps, File.streams()[1].Type);
   EXPECT_EQ("400d9000-400db000 r-xp 00000000 b3:04 227        "
             "/system/bin/app_process\n"
             "400db000-400dc000 r--p 00001000 b3:04 227        "
             "/system/bin/app_process\n",
             toStringRef(*File.getRawStream(StreamType::LinuxMaps)));

   EXPECT_EQ(StreamType::LinuxAuxv, File.streams()[2].Type);
   EXPECT_EQ((ArrayRef<uint8_t>{0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD, 0xF0, 0x0D}),
             File.getRawStream(StreamType::LinuxAuxv));
 }

 TEST(MinidumpYAML, RawContent) {
   SmallString<0> Storage;
   auto ExpectedFile = toBinary(Storage, R"(
 --- !minidump
 Streams:
   - Type:            LinuxAuxv
     Size:            9
     Content:         DEADBEEFBAADF00D)");
   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
   object::MinidumpFile &File = **ExpectedFile;

   EXPECT_EQ(
       (ArrayRef<uint8_t>{0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD, 0xF0, 0x0D, 0x00}),
       File.getRawStream(StreamType::LinuxAuxv));
 }

 TEST(MinidumpYAML, X86SystemInfo) {
   SmallString<0> Storage;
   auto ExpectedFile = toBinary(Storage, R"(
 --- !minidump
 Streams:
   - Type:            SystemInfo
     Processor Arch:  X86
     Platform ID:     Linux
     CPU:
       Vendor ID:       LLVMLLVMLLVM
       Version Info:    0x01020304
       Feature Info:    0x05060708
       AMD Extended Features: 0x09000102)");
   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
   object::MinidumpFile &File = **ExpectedFile;

   ASSERT_EQ(1u, File.streams().size());

   auto ExpectedSysInfo = File.getSystemInfo();
   ASSERT_THAT_EXPECTED(ExpectedSysInfo, Succeeded());
   const SystemInfo &SysInfo = *ExpectedSysInfo;
   EXPECT_EQ(ProcessorArchitecture::X86, SysInfo.ProcessorArch);
   EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
   EXPECT_EQ("LLVMLLVMLLVM", StringRef(SysInfo.CPU.X86.VendorID,
                                       sizeof(SysInfo.CPU.X86.VendorID)));
   EXPECT_EQ(0x01020304u, SysInfo.CPU.X86.VersionInfo);
   EXPECT_EQ(0x05060708u, SysInfo.CPU.X86.FeatureInfo);
   EXPECT_EQ(0x09000102u, SysInfo.CPU.X86.AMDExtendedFeatures);
 }

 TEST(MinidumpYAML, OtherSystemInfo) {
   SmallString<0> Storage;
   auto ExpectedFile = toBinary(Storage, R"(
 --- !minidump
 Streams:
   - Type:            SystemInfo
     Processor Arch:  PPC
     Platform ID:     Linux
     CPU:
       Features:        000102030405060708090a0b0c0d0e0f)");
   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
   object::MinidumpFile &File = **ExpectedFile;

   ASSERT_EQ(1u, File.streams().size());

   auto ExpectedSysInfo = File.getSystemInfo();
   ASSERT_THAT_EXPECTED(ExpectedSysInfo, Succeeded());
   const SystemInfo &SysInfo = *ExpectedSysInfo;
   EXPECT_EQ(ProcessorArchitecture::PPC, SysInfo.ProcessorArch);
   EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
   EXPECT_EQ(
       (ArrayRef<uint8_t>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}),
       ArrayRef(SysInfo.CPU.Other.ProcessorFeatures));
 }

 // Test that we can parse a normal-looking ExceptionStream.
 TEST(MinidumpYAML, ExceptionStream) {
   SmallString<0> Storage;
   auto ExpectedFile = toBinary(Storage, R"(
 --- !minidump
 Streams:
   - Type:            Exception
     Thread ID:  0x7
     Exception Record:
       Exception Code:  0x23
       Exception Flags: 0x5
       Exception Record: 0x0102030405060708
       Exception Address: 0x0a0b0c0d0e0f1011
       Number of Parameters: 2
       Parameter 0: 0x22
       Parameter 1: 0x24
     Thread Context:  3DeadBeefDefacedABadCafe)");
   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
   object::MinidumpFile &File = **ExpectedFile;

   ASSERT_EQ(1u, File.streams().size());

   auto ExceptionIterator = File.getExceptionStreams().begin();

   Expected<const ExceptionStream &> ExpectedStream = *ExceptionIterator;

   ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());

   const minidump::ExceptionStream &Stream = *ExpectedStream;
   EXPECT_EQ(0x7u, Stream.ThreadId);
   const minidump::Exception &Exception = Stream.ExceptionRecord;
   EXPECT_EQ(0x23u, Exception.ExceptionCode);
   EXPECT_EQ(0x5u, Exception.ExceptionFlags);
   EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
   EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
   EXPECT_EQ(2u, Exception.NumberParameters);
   EXPECT_EQ(0x22u, Exception.ExceptionInformation[0]);
   EXPECT_EQ(0x24u, Exception.ExceptionInformation[1]);

   Expected<ArrayRef<uint8_t>> ExpectedContext =
       File.getRawData(Stream.ThreadContext);
   ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
   EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
                                0xab, 0xad, 0xca, 0xfe}),
             *ExpectedContext);
 }

 // Test that we can parse an exception stream with no ExceptionInformation.
 TEST(MinidumpYAML, ExceptionStream_NoParameters) {
   SmallString<0> Storage;
   auto ExpectedFile = toBinary(Storage, R"(
 --- !minidump
 Streams:
   - Type:            Exception
     Thread ID:  0x7
     Exception Record:
       Exception Code:  0x23
       Exception Flags: 0x5
       Exception Record: 0x0102030405060708
       Exception Address: 0x0a0b0c0d0e0f1011
     Thread Context:  3DeadBeefDefacedABadCafe)");
   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
   object::MinidumpFile &File = **ExpectedFile;

   ASSERT_EQ(1u, File.streams().size());

   auto ExceptionIterator = File.getExceptionStreams().begin();

   Expected<const ExceptionStream &> ExpectedStream = *ExceptionIterator;
   ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());

   const minidump::ExceptionStream &Stream = *ExpectedStream;
   EXPECT_EQ(0x7u, Stream.ThreadId);
   const minidump::Exception &Exception = Stream.ExceptionRecord;
   EXPECT_EQ(0x23u, Exception.ExceptionCode);
   EXPECT_EQ(0x5u, Exception.ExceptionFlags);
   EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
   EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
   EXPECT_EQ(0u, Exception.NumberParameters);

   Expected<ArrayRef<uint8_t>> ExpectedContext =
       File.getRawData(Stream.ThreadContext);
   ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
   EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
                                0xab, 0xad, 0xca, 0xfe}),
             *ExpectedContext);
 }

 // Test that we can parse an ExceptionStream where the stated number of
 // parameters is greater than the actual size of the ExceptionInformation
 // array.
 TEST(MinidumpYAML, ExceptionStream_TooManyParameters) {
   SmallString<0> Storage;
   auto ExpectedFile = toBinary(Storage, R"(
 --- !minidump
 Streams:
   - Type:            Exception
     Thread ID:  0x8
     Exception Record:
       Exception Code: 0
       Number of Parameters: 16
       Parameter 0: 0x0
       Parameter 1: 0xff
       Parameter 2: 0xee
       Parameter 3: 0xdd
       Parameter 4: 0xcc
       Parameter 5: 0xbb
       Parameter 6: 0xaa
       Parameter 7: 0x99
       Parameter 8: 0x88
       Parameter 9: 0x77
       Parameter 10: 0x66
       Parameter 11: 0x55
       Parameter 12: 0x44
       Parameter 13: 0x33
       Parameter 14: 0x22
     Thread Context:  3DeadBeefDefacedABadCafe)");
   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
   object::MinidumpFile &File = **ExpectedFile;

   ASSERT_EQ(1u, File.streams().size());

   auto ExceptionIterator = File.getExceptionStreams().begin();

   Expected<const ExceptionStream &> ExpectedStream = *ExceptionIterator;

   ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());

   const minidump::ExceptionStream &Stream = *ExpectedStream;
   EXPECT_EQ(0x8u, Stream.ThreadId);
   const minidump::Exception &Exception = Stream.ExceptionRecord;
   EXPECT_EQ(0x0u, Exception.ExceptionCode);
   EXPECT_EQ(0x0u, Exception.ExceptionFlags);
   EXPECT_EQ(0x00u, Exception.ExceptionRecord);
   EXPECT_EQ(0x0u, Exception.ExceptionAddress);
   EXPECT_EQ(16u, Exception.NumberParameters);
   EXPECT_EQ(0x0u, Exception.ExceptionInformation[0]);
   for (int Index = 1; Index < 15; ++Index) {
     EXPECT_EQ(0x110u - Index * 0x11, Exception.ExceptionInformation[Index]);
   }

   Expected<ArrayRef<uint8_t>> ExpectedContext =
       File.getRawData(Stream.ThreadContext);
   ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
   EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
                                0xab, 0xad, 0xca, 0xfe}),
             *ExpectedContext);
 }

 // Test that we can parse an ExceptionStream where the number of
 // ExceptionInformation parameters provided is greater than the
 // specified Number of Parameters.
 TEST(MinidumpYAML, ExceptionStream_ExtraParameter) {
   SmallString<0> Storage;
   auto ExpectedFile = toBinary(Storage, R"(
 --- !minidump
 Streams:
   - Type:            Exception
     Thread ID:  0x7
     Exception Record:
       Exception Code:  0x23
       Exception Flags: 0x5
       Exception Record: 0x0102030405060708
       Exception Address: 0x0a0b0c0d0e0f1011
       Number of Parameters: 2
       Parameter 0: 0x99
       Parameter 1: 0x23
       Parameter 2: 0x42
     Thread Context:  3DeadBeefDefacedABadCafe)");
   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
   object::MinidumpFile &File = **ExpectedFile;

   ASSERT_EQ(1u, File.streams().size());

   auto ExceptionIterator = File.getExceptionStreams().begin();

   Expected<const ExceptionStream &> ExpectedStream = *ExceptionIterator;

   ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());

   const minidump::ExceptionStream &Stream = *ExpectedStream;
   EXPECT_EQ(0x7u, Stream.ThreadId);
   const minidump::Exception &Exception = Stream.ExceptionRecord;
   EXPECT_EQ(0x23u, Exception.ExceptionCode);
   EXPECT_EQ(0x5u, Exception.ExceptionFlags);
   EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
   EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
   EXPECT_EQ(2u, Exception.NumberParameters);
   EXPECT_EQ(0x99u, Exception.ExceptionInformation[0]);
   EXPECT_EQ(0x23u, Exception.ExceptionInformation[1]);
   EXPECT_EQ(0x42u, Exception.ExceptionInformation[2]);

   Expected<ArrayRef<uint8_t>> ExpectedContext =
       File.getRawData(Stream.ThreadContext);
   ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
   EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
                                0xab, 0xad, 0xca, 0xfe}),
             *ExpectedContext);
 }

 TEST(MinidumpYAML, MemoryRegion_64bit) {
   SmallString<0> Storage;
   auto ExpectedFile = toBinary(Storage, R"(
 --- !minidump
 Streams:
   - Type:            Memory64List
     Memory Ranges:
       - Start of Memory Range: 0x7FFFFFCF0818283
         Content:               '68656c6c6f'
       - Start of Memory Range: 0x7FFFFFFF0818283
         Content:               '776f726c64'
         )");

   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
   object::MinidumpFile &File = **ExpectedFile;

   ASSERT_THAT(File.streams().size(), 1u);

   Error Err = Error::success();
   iterator_range<object::MinidumpFile::FallibleMemory64Iterator> MemoryList =
       File.getMemory64List(Err);

   ASSERT_THAT_ERROR(std::move(Err), Succeeded());
   auto Iterator = MemoryList.begin();

   auto DescOnePair = *Iterator;
   const minidump::MemoryDescriptor_64 &DescOne = DescOnePair.first;
   ASSERT_THAT(DescOne.StartOfMemoryRange, 0x7FFFFFCF0818283u);
   ASSERT_THAT(DescOne.DataSize, 5u);
   ++Iterator;
   ASSERT_THAT_ERROR(std::move(Err), Succeeded());

   auto DescTwoPair = *Iterator;
   const minidump::MemoryDescriptor_64 &DescTwo = DescTwoPair.first;
   ASSERT_THAT(DescTwo.StartOfMemoryRange, 0x7FFFFFFF0818283u);
   ASSERT_THAT(DescTwo.DataSize, 5u);
   ++Iterator;
   ASSERT_THAT_ERROR(std::move(Err), Succeeded());

   const std::optional<ArrayRef<uint8_t>> ExpectedContent =
       File.getRawStream(StreamType::Memory64List);
   ASSERT_TRUE(ExpectedContent);
   const size_t ExpectedStreamSize =
       sizeof(Memory64ListHeader) + (sizeof(MemoryDescriptor_64) * 2);
   ASSERT_THAT(ExpectedContent->size(), ExpectedStreamSize);

   Expected<minidump::Memory64ListHeader> ExpectedHeader =
       File.getMemoryList64Header();
   ASSERT_THAT_EXPECTED(ExpectedHeader, Succeeded());
   ASSERT_THAT(ExpectedHeader->BaseRVA, 92u);

   Expected<ArrayRef<uint8_t>> DescOneExpectedContentSlice = DescOnePair.second;
   ASSERT_THAT_EXPECTED(DescOneExpectedContentSlice, Succeeded());
   ASSERT_THAT(DescOneExpectedContentSlice->size(), 5u);
   ASSERT_THAT(*DescOneExpectedContentSlice, arrayRefFromStringRef("hello"));

   Expected<ArrayRef<uint8_t>> DescTwoExpectedContentSlice = DescTwoPair.second;
   ASSERT_THAT_EXPECTED(DescTwoExpectedContentSlice, Succeeded());
   ASSERT_THAT(*DescTwoExpectedContentSlice, arrayRefFromStringRef("world"));

   ASSERT_EQ(Iterator, MemoryList.end());
 }

 // Test that we can parse multiple exception streams.
 TEST(MinidumpYAML, ExceptionStream_MultipleExceptions) {
   SmallString<0> Storage;
   auto ExpectedFile = toBinary(Storage, R"(
 --- !minidump
 Streams:
   - Type:            Exception
     Thread ID:  0x7
     Exception Record:
       Exception Code:  0x23
       Exception Flags: 0x5
       Exception Record: 0x0102030405060708
       Exception Address: 0x0a0b0c0d0e0f1011
       Number of Parameters: 2
       Parameter 0: 0x99
       Parameter 1: 0x23
       Parameter 2: 0x42
     Thread Context:  3DeadBeefDefacedABadCafe
   - Type:            Exception
     Thread ID:  0x5
     Exception Record:
       Exception Code:  0x23
       Exception Flags: 0x5
       Exception Record: 0x0102030405060708
       Exception Address: 0x0a0b0c0d0e0f1011
     Thread Context:  3DeadBeefDefacedABadCafe)");

   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
   object::MinidumpFile &File = **ExpectedFile;

   ASSERT_EQ(2u, File.streams().size());

   size_t count = 0;
   for (auto exception_stream : File.getExceptionStreams()) {
     count++;
     ASSERT_THAT_EXPECTED(exception_stream, Succeeded());
     ASSERT_THAT(0x23u, exception_stream->ExceptionRecord.ExceptionCode);
   }

   ASSERT_THAT(2u, count);
 }
	//===- MinidumpYAMLTest.cpp - Tests for Minidump<->YAML code --------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "llvm/Object/Minidump.h"
	#include "llvm/ObjectYAML/yaml2obj.h"
	#include "llvm/Support/YAMLTraits.h"
	#include "llvm/Testing/Support/Error.h"
	#include "gtest/gtest.h"

	using namespace llvm;
	using namespace llvm::minidump;

	static Expected<std::unique_ptr<object::MinidumpFile>>
	toBinary(SmallVectorImpl<char> &Storage, StringRef Yaml) {
	Storage.clear();
	raw_svector_ostream OS(Storage);
	yaml::Input YIn(Yaml);
	if (!yaml::convertYAML(YIn, OS, [](const Twine &Msg) {}))
	return createStringError(std::errc::invalid_argument,
	"unable to convert YAML");

	return object::MinidumpFile::create(MemoryBufferRef(OS.str(), "Binary"));
	}

	TEST(MinidumpYAML, Basic) {
	SmallString<0> Storage;
	auto ExpectedFile = toBinary(Storage, R"(
	--- !minidump
	Streams:
	- Type: SystemInfo
	Processor Arch: ARM64
	Platform ID: Linux
	CPU:
	CPUID: 0x05060708
	- Type: LinuxMaps
	Text: \|
	400d9000-400db000 r-xp 00000000 b3:04 227 /system/bin/app_process
	400db000-400dc000 r--p 00001000 b3:04 227 /system/bin/app_process

	- Type: LinuxAuxv
	Content: DEADBEEFBAADF00D)");
	ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
	object::MinidumpFile &File = **ExpectedFile;

	ASSERT_EQ(3u, File.streams().size());

	EXPECT_EQ(StreamType::SystemInfo, File.streams()[0].Type);
	auto ExpectedSysInfo = File.getSystemInfo();
	ASSERT_THAT_EXPECTED(ExpectedSysInfo, Succeeded());
	const SystemInfo &SysInfo = *ExpectedSysInfo;
	EXPECT_EQ(ProcessorArchitecture::ARM64, SysInfo.ProcessorArch);
	EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
	EXPECT_EQ(0x05060708u, SysInfo.CPU.Arm.CPUID);

	EXPECT_EQ(StreamType::LinuxMaps, File.streams()[1].Type);
	EXPECT_EQ("400d9000-400db000 r-xp 00000000 b3:04 227 "
	"/system/bin/app_process\n"
	"400db000-400dc000 r--p 00001000 b3:04 227 "
	"/system/bin/app_process\n",
	toStringRef(*File.getRawStream(StreamType::LinuxMaps)));

	EXPECT_EQ(StreamType::LinuxAuxv, File.streams()[2].Type);
	EXPECT_EQ((ArrayRef<uint8_t>{0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD, 0xF0, 0x0D}),
	File.getRawStream(StreamType::LinuxAuxv));
	}

	TEST(MinidumpYAML, RawContent) {
	SmallString<0> Storage;
	auto ExpectedFile = toBinary(Storage, R"(
	--- !minidump
	Streams:
	- Type: LinuxAuxv
	Size: 9
	Content: DEADBEEFBAADF00D)");
	ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
	object::MinidumpFile &File = **ExpectedFile;

	EXPECT_EQ(
	(ArrayRef<uint8_t>{0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD, 0xF0, 0x0D, 0x00}),
	File.getRawStream(StreamType::LinuxAuxv));
	}

	TEST(MinidumpYAML, X86SystemInfo) {
	SmallString<0> Storage;
	auto ExpectedFile = toBinary(Storage, R"(
	--- !minidump
	Streams:
	- Type: SystemInfo
	Processor Arch: X86
	Platform ID: Linux
	CPU:
	Vendor ID: LLVMLLVMLLVM
	Version Info: 0x01020304
	Feature Info: 0x05060708
	AMD Extended Features: 0x09000102)");
	ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
	object::MinidumpFile &File = **ExpectedFile;

	ASSERT_EQ(1u, File.streams().size());

	auto ExpectedSysInfo = File.getSystemInfo();
	ASSERT_THAT_EXPECTED(ExpectedSysInfo, Succeeded());
	const SystemInfo &SysInfo = *ExpectedSysInfo;
	EXPECT_EQ(ProcessorArchitecture::X86, SysInfo.ProcessorArch);
	EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
	EXPECT_EQ("LLVMLLVMLLVM", StringRef(SysInfo.CPU.X86.VendorID,
	sizeof(SysInfo.CPU.X86.VendorID)));
	EXPECT_EQ(0x01020304u, SysInfo.CPU.X86.VersionInfo);
	EXPECT_EQ(0x05060708u, SysInfo.CPU.X86.FeatureInfo);
	EXPECT_EQ(0x09000102u, SysInfo.CPU.X86.AMDExtendedFeatures);
	}

	TEST(MinidumpYAML, OtherSystemInfo) {
	SmallString<0> Storage;
	auto ExpectedFile = toBinary(Storage, R"(
	--- !minidump
	Streams:
	- Type: SystemInfo
	Processor Arch: PPC
	Platform ID: Linux
	CPU:
	Features: 000102030405060708090a0b0c0d0e0f)");
	ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
	object::MinidumpFile &File = **ExpectedFile;

	ASSERT_EQ(1u, File.streams().size());

	auto ExpectedSysInfo = File.getSystemInfo();
	ASSERT_THAT_EXPECTED(ExpectedSysInfo, Succeeded());
	const SystemInfo &SysInfo = *ExpectedSysInfo;
	EXPECT_EQ(ProcessorArchitecture::PPC, SysInfo.ProcessorArch);
	EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
	EXPECT_EQ(
	(ArrayRef<uint8_t>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}),
	ArrayRef(SysInfo.CPU.Other.ProcessorFeatures));
	}

	// Test that we can parse a normal-looking ExceptionStream.
	TEST(MinidumpYAML, ExceptionStream) {
	SmallString<0> Storage;
	auto ExpectedFile = toBinary(Storage, R"(
	--- !minidump
	Streams:
	- Type: Exception
	Thread ID: 0x7
	Exception Record:
	Exception Code: 0x23
	Exception Flags: 0x5
	Exception Record: 0x0102030405060708
	Exception Address: 0x0a0b0c0d0e0f1011
	Number of Parameters: 2
	Parameter 0: 0x22
	Parameter 1: 0x24
	Thread Context: 3DeadBeefDefacedABadCafe)");
	ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
	object::MinidumpFile &File = **ExpectedFile;

	ASSERT_EQ(1u, File.streams().size());

	auto ExceptionIterator = File.getExceptionStreams().begin();

	Expected<const ExceptionStream &> ExpectedStream = *ExceptionIterator;

	ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());

	const minidump::ExceptionStream &Stream = *ExpectedStream;
	EXPECT_EQ(0x7u, Stream.ThreadId);
	const minidump::Exception &Exception = Stream.ExceptionRecord;
	EXPECT_EQ(0x23u, Exception.ExceptionCode);
	EXPECT_EQ(0x5u, Exception.ExceptionFlags);
	EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
	EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
	EXPECT_EQ(2u, Exception.NumberParameters);
	EXPECT_EQ(0x22u, Exception.ExceptionInformation[0]);
	EXPECT_EQ(0x24u, Exception.ExceptionInformation[1]);

	Expected<ArrayRef<uint8_t>> ExpectedContext =
	File.getRawData(Stream.ThreadContext);
	ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
	EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
	0xab, 0xad, 0xca, 0xfe}),
	*ExpectedContext);
	}

	// Test that we can parse an exception stream with no ExceptionInformation.
	TEST(MinidumpYAML, ExceptionStream_NoParameters) {
	SmallString<0> Storage;
	auto ExpectedFile = toBinary(Storage, R"(
	--- !minidump
	Streams:
	- Type: Exception
	Thread ID: 0x7
	Exception Record:
	Exception Code: 0x23
	Exception Flags: 0x5
	Exception Record: 0x0102030405060708
	Exception Address: 0x0a0b0c0d0e0f1011
	Thread Context: 3DeadBeefDefacedABadCafe)");
	ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
	object::MinidumpFile &File = **ExpectedFile;

	ASSERT_EQ(1u, File.streams().size());

	auto ExceptionIterator = File.getExceptionStreams().begin();

	Expected<const ExceptionStream &> ExpectedStream = *ExceptionIterator;
	ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());

	const minidump::ExceptionStream &Stream = *ExpectedStream;
	EXPECT_EQ(0x7u, Stream.ThreadId);
	const minidump::Exception &Exception = Stream.ExceptionRecord;
	EXPECT_EQ(0x23u, Exception.ExceptionCode);
	EXPECT_EQ(0x5u, Exception.ExceptionFlags);
	EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
	EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
	EXPECT_EQ(0u, Exception.NumberParameters);

	Expected<ArrayRef<uint8_t>> ExpectedContext =
	File.getRawData(Stream.ThreadContext);
	ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
	EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
	0xab, 0xad, 0xca, 0xfe}),
	*ExpectedContext);
	}

	// Test that we can parse an ExceptionStream where the stated number of
	// parameters is greater than the actual size of the ExceptionInformation
	// array.
	TEST(MinidumpYAML, ExceptionStream_TooManyParameters) {
	SmallString<0> Storage;
	auto ExpectedFile = toBinary(Storage, R"(
	--- !minidump
	Streams:
	- Type: Exception
	Thread ID: 0x8
	Exception Record:
	Exception Code: 0
	Number of Parameters: 16
	Parameter 0: 0x0
	Parameter 1: 0xff
	Parameter 2: 0xee
	Parameter 3: 0xdd
	Parameter 4: 0xcc
	Parameter 5: 0xbb
	Parameter 6: 0xaa
	Parameter 7: 0x99
	Parameter 8: 0x88
	Parameter 9: 0x77
	Parameter 10: 0x66
	Parameter 11: 0x55
	Parameter 12: 0x44
	Parameter 13: 0x33
	Parameter 14: 0x22
	Thread Context: 3DeadBeefDefacedABadCafe)");
	ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
	object::MinidumpFile &File = **ExpectedFile;

	ASSERT_EQ(1u, File.streams().size());

	auto ExceptionIterator = File.getExceptionStreams().begin();

	Expected<const ExceptionStream &> ExpectedStream = *ExceptionIterator;

	ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());

	const minidump::ExceptionStream &Stream = *ExpectedStream;
	EXPECT_EQ(0x8u, Stream.ThreadId);
	const minidump::Exception &Exception = Stream.ExceptionRecord;
	EXPECT_EQ(0x0u, Exception.ExceptionCode);
	EXPECT_EQ(0x0u, Exception.ExceptionFlags);
	EXPECT_EQ(0x00u, Exception.ExceptionRecord);
	EXPECT_EQ(0x0u, Exception.ExceptionAddress);
	EXPECT_EQ(16u, Exception.NumberParameters);
	EXPECT_EQ(0x0u, Exception.ExceptionInformation[0]);
	for (int Index = 1; Index < 15; ++Index) {
	EXPECT_EQ(0x110u - Index * 0x11, Exception.ExceptionInformation[Index]);
	}

	Expected<ArrayRef<uint8_t>> ExpectedContext =
	File.getRawData(Stream.ThreadContext);
	ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
	EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
	0xab, 0xad, 0xca, 0xfe}),
	*ExpectedContext);
	}

	// Test that we can parse an ExceptionStream where the number of
	// ExceptionInformation parameters provided is greater than the
	// specified Number of Parameters.
	TEST(MinidumpYAML, ExceptionStream_ExtraParameter) {
	SmallString<0> Storage;
	auto ExpectedFile = toBinary(Storage, R"(
	--- !minidump
	Streams:
	- Type: Exception
	Thread ID: 0x7
	Exception Record:
	Exception Code: 0x23
	Exception Flags: 0x5
	Exception Record: 0x0102030405060708
	Exception Address: 0x0a0b0c0d0e0f1011
	Number of Parameters: 2
	Parameter 0: 0x99
	Parameter 1: 0x23
	Parameter 2: 0x42
	Thread Context: 3DeadBeefDefacedABadCafe)");
	ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
	object::MinidumpFile &File = **ExpectedFile;

	ASSERT_EQ(1u, File.streams().size());

	auto ExceptionIterator = File.getExceptionStreams().begin();

	Expected<const ExceptionStream &> ExpectedStream = *ExceptionIterator;

	ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());

	const minidump::ExceptionStream &Stream = *ExpectedStream;
	EXPECT_EQ(0x7u, Stream.ThreadId);
	const minidump::Exception &Exception = Stream.ExceptionRecord;
	EXPECT_EQ(0x23u, Exception.ExceptionCode);
	EXPECT_EQ(0x5u, Exception.ExceptionFlags);
	EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
	EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
	EXPECT_EQ(2u, Exception.NumberParameters);
	EXPECT_EQ(0x99u, Exception.ExceptionInformation[0]);
	EXPECT_EQ(0x23u, Exception.ExceptionInformation[1]);
	EXPECT_EQ(0x42u, Exception.ExceptionInformation[2]);

	Expected<ArrayRef<uint8_t>> ExpectedContext =
	File.getRawData(Stream.ThreadContext);
	ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
	EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
	0xab, 0xad, 0xca, 0xfe}),
	*ExpectedContext);
	}

	TEST(MinidumpYAML, MemoryRegion_64bit) {
	SmallString<0> Storage;
	auto ExpectedFile = toBinary(Storage, R"(
	--- !minidump
	Streams:
	- Type: Memory64List
	Memory Ranges:
	- Start of Memory Range: 0x7FFFFFCF0818283
	Content: '68656c6c6f'
	- Start of Memory Range: 0x7FFFFFFF0818283
	Content: '776f726c64'
	)");

	ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
	object::MinidumpFile &File = **ExpectedFile;

	ASSERT_THAT(File.streams().size(), 1u);

	Error Err = Error::success();
	iterator_range<object::MinidumpFile::FallibleMemory64Iterator> MemoryList =
	File.getMemory64List(Err);

	ASSERT_THAT_ERROR(std::move(Err), Succeeded());
	auto Iterator = MemoryList.begin();

	auto DescOnePair = *Iterator;
	const minidump::MemoryDescriptor_64 &DescOne = DescOnePair.first;
	ASSERT_THAT(DescOne.StartOfMemoryRange, 0x7FFFFFCF0818283u);
	ASSERT_THAT(DescOne.DataSize, 5u);
	++Iterator;
	ASSERT_THAT_ERROR(std::move(Err), Succeeded());

	auto DescTwoPair = *Iterator;
	const minidump::MemoryDescriptor_64 &DescTwo = DescTwoPair.first;
	ASSERT_THAT(DescTwo.StartOfMemoryRange, 0x7FFFFFFF0818283u);
	ASSERT_THAT(DescTwo.DataSize, 5u);
	++Iterator;
	ASSERT_THAT_ERROR(std::move(Err), Succeeded());

	const std::optional<ArrayRef<uint8_t>> ExpectedContent =
	File.getRawStream(StreamType::Memory64List);
	ASSERT_TRUE(ExpectedContent);
	const size_t ExpectedStreamSize =
	sizeof(Memory64ListHeader) + (sizeof(MemoryDescriptor_64) * 2);
	ASSERT_THAT(ExpectedContent->size(), ExpectedStreamSize);

	Expected<minidump::Memory64ListHeader> ExpectedHeader =
	File.getMemoryList64Header();
	ASSERT_THAT_EXPECTED(ExpectedHeader, Succeeded());
	ASSERT_THAT(ExpectedHeader->BaseRVA, 92u);

	Expected<ArrayRef<uint8_t>> DescOneExpectedContentSlice = DescOnePair.second;
	ASSERT_THAT_EXPECTED(DescOneExpectedContentSlice, Succeeded());
	ASSERT_THAT(DescOneExpectedContentSlice->size(), 5u);
	ASSERT_THAT(*DescOneExpectedContentSlice, arrayRefFromStringRef("hello"));

	Expected<ArrayRef<uint8_t>> DescTwoExpectedContentSlice = DescTwoPair.second;
	ASSERT_THAT_EXPECTED(DescTwoExpectedContentSlice, Succeeded());
	ASSERT_THAT(*DescTwoExpectedContentSlice, arrayRefFromStringRef("world"));

	ASSERT_EQ(Iterator, MemoryList.end());
	}

	// Test that we can parse multiple exception streams.
	TEST(MinidumpYAML, ExceptionStream_MultipleExceptions) {
	SmallString<0> Storage;
	auto ExpectedFile = toBinary(Storage, R"(
	--- !minidump
	Streams:
	- Type: Exception
	Thread ID: 0x7
	Exception Record:
	Exception Code: 0x23
	Exception Flags: 0x5
	Exception Record: 0x0102030405060708
	Exception Address: 0x0a0b0c0d0e0f1011
	Number of Parameters: 2
	Parameter 0: 0x99
	Parameter 1: 0x23
	Parameter 2: 0x42
	Thread Context: 3DeadBeefDefacedABadCafe
	- Type: Exception
	Thread ID: 0x5
	Exception Record:
	Exception Code: 0x23
	Exception Flags: 0x5
	Exception Record: 0x0102030405060708
	Exception Address: 0x0a0b0c0d0e0f1011
	Thread Context: 3DeadBeefDefacedABadCafe)");

	ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
	object::MinidumpFile &File = **ExpectedFile;

	ASSERT_EQ(2u, File.streams().size());

	size_t count = 0;
	for (auto exception_stream : File.getExceptionStreams()) {
	count++;
	ASSERT_THAT_EXPECTED(exception_stream, Succeeded());
	ASSERT_THAT(0x23u, exception_stream->ExceptionRecord.ExceptionCode);
	}

	ASSERT_THAT(2u, count);
	}