unittests/DebugInfo/LogicalView/CompareElementsTest.cpp - llvm-project/llvm - Git at Google

 //===- llvm/unittest/DebugInfo/LogicalView/CompareElementsTest.cpp --------===//
 //
 // 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/DebugInfo/LogicalView/Core/LVCompare.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVLine.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVReader.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVType.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Testing/Support/Error.h"

 #include "gtest/gtest.h"

 using namespace llvm;
 using namespace llvm::logicalview;

 namespace {

 //===----------------------------------------------------------------------===//
 // Basic Reader functionality.
 class ReaderTestCompare : public LVReader {
 #define CREATE(VARIABLE, CREATE_FUNCTION, SET_FUNCTION)                        \
   VARIABLE = CREATE_FUNCTION();                                                \
   EXPECT_NE(VARIABLE, nullptr);                                                \
   VARIABLE->SET_FUNCTION();

 public:
   // Types.
   LVType *IntegerType = nullptr;
   LVType *UnsignedType = nullptr;
   LVType *GlobalType = nullptr;
   LVType *LocalType = nullptr;
   LVType *NestedType = nullptr;
   LVTypeDefinition *TypeDefinitionOne = nullptr;
   LVTypeDefinition *TypeDefinitionTwo = nullptr;
   LVTypeEnumerator *EnumeratorOne = nullptr;
   LVTypeEnumerator *EnumeratorTwo = nullptr;

   // Scopes.
   LVScope *NestedScope = nullptr;
   LVScope *InnerScope = nullptr;
   LVScopeAggregate *Aggregate = nullptr;
   LVScopeEnumeration *Enumeration = nullptr;
   LVScopeFunction *FunctionOne = nullptr;
   LVScopeFunction *FunctionTwo = nullptr;
   LVScopeNamespace *Namespace = nullptr;

   // Symbols.
   LVSymbol *GlobalVariable = nullptr;
   LVSymbol *LocalVariable = nullptr;
   LVSymbol *ClassMember = nullptr;
   LVSymbol *NestedVariable = nullptr;
   LVSymbol *ParameterOne = nullptr;
   LVSymbol *ParameterTwo = nullptr;

   // Lines.
   LVLine *LineOne = nullptr;
   LVLine *LineTwo = nullptr;
   LVLine *LineThree = nullptr;

 protected:
   void add(LVScope *Parent, LVElement *Element);
   void set(LVElement *Element, StringRef Name, LVOffset Offset,
            uint32_t LineNumber = 0, LVElement *Type = nullptr);

 public:
   ReaderTestCompare(ScopedPrinter &W) : LVReader("", "", W) {
     setInstance(this);
   }

   Error createScopes() { return LVReader::createScopes(); }
   Error printScopes() { return LVReader::printScopes(); }

   void createElements();
   void addElements(bool IsReference, bool IsTarget);
   void initElements();
 };

 // Helper function to add a logical element to a given scope.
 void ReaderTestCompare::add(LVScope *Parent, LVElement *Child) {
   Parent->addElement(Child);
   EXPECT_EQ(Child->getParent(), Parent);
   EXPECT_EQ(Child->getLevel(), Parent->getLevel() + 1);
 }

 // Helper function to set the initial values for a given logical element.
 void ReaderTestCompare::set(LVElement *Element, StringRef Name, LVOffset Offset,
                             uint32_t LineNumber, LVElement *Type) {
   Element->setName(Name);
   Element->setOffset(Offset);
   Element->setLineNumber(LineNumber);
   Element->setType(Type);
 }

 //===----------------------------------------------------------------------===//
 // Create the logical elements.
 void ReaderTestCompare::createElements() {
   // Create scope root.
   Error Err = createScopes();
   ASSERT_THAT_ERROR(std::move(Err), Succeeded());
   Root = getScopesRoot();
   ASSERT_NE(Root, nullptr);

   // Create the logical types.
   CREATE(IntegerType, createType, setIsBase);
   CREATE(UnsignedType, createType, setIsBase);
   CREATE(GlobalType, createType, setIsBase);
   CREATE(LocalType, createType, setIsBase);
   CREATE(NestedType, createType, setIsBase);
   CREATE(EnumeratorOne, createTypeEnumerator, setIsEnumerator);
   CREATE(EnumeratorTwo, createTypeEnumerator, setIsEnumerator);
   CREATE(TypeDefinitionOne, createTypeDefinition, setIsTypedef);
   CREATE(TypeDefinitionTwo, createTypeDefinition, setIsTypedef);

   // Create the logical scopes.
   CREATE(NestedScope, createScope, setIsLexicalBlock);
   CREATE(InnerScope, createScope, setIsLexicalBlock);
   CREATE(Aggregate, createScopeAggregate, setIsAggregate);
   CREATE(CompileUnit, createScopeCompileUnit, setIsCompileUnit);
   CREATE(Enumeration, createScopeEnumeration, setIsEnumeration);
   CREATE(FunctionOne, createScopeFunction, setIsFunction);
   CREATE(FunctionTwo, createScopeFunction, setIsFunction);
   CREATE(Namespace, createScopeNamespace, setIsNamespace);

   // Create the logical symbols.
   CREATE(GlobalVariable, createSymbol, setIsVariable);
   CREATE(LocalVariable, createSymbol, setIsVariable);
   CREATE(ClassMember, createSymbol, setIsMember);
   CREATE(NestedVariable, createSymbol, setIsVariable);
   CREATE(ParameterOne, createSymbol, setIsParameter);
   CREATE(ParameterTwo, createSymbol, setIsParameter);

   // Create the logical lines.
   CREATE(LineOne, createLine, setIsLineDebug);
   CREATE(LineTwo, createLine, setIsLineDebug);
   CREATE(LineThree, createLine, setIsLineDebug);
 }

 // Reference Reader:              Target Reader:
 // ----------------------         ----------------------
 // Root                           Root
 //   CompileUnit                    CompileUnit
 //     IntegerType                    IntegerType
 //     UnsignedType                   UnsignedType
 //     FunctionOne                    FunctionOne
 //       ParameterOne                   ParameterOne
 //       LocalVariable                  ---
 //       LocalType                      LocalType
 //       LineOne                        LineOne
 //       NestedScope                    NestedScope
 //         NestedVariable                 NestedVariable
 //         NestedType                     NestedType
 //         LineTwo                        ---
 //         InnerScope                     InnerScope
 //           ---                            LineThree
 //     ---                            FunctionTwo
 //     ---                              ParameterTwo
 //     GlobalVariable                 GlobalVariable
 //     GlobalType                     GlobalType
 //     Namespace                      Namespace
 //       Aggregate                      Aggregate
 //         ClassMember                    ClassMember
 //       Enumeration                    Enumeration
 //         EnumeratorOne                  EnumeratorOne
 //         EnumeratorTwo                  EnumeratorTwo
 //       TypeDefinitionOne              ---
 //       ---                            TypeDefinitionTwo

 // Create the logical view adding the created logical elements.
 void ReaderTestCompare::addElements(bool IsReference, bool IsTarget) {
   Root->setName(IsReference ? "Reference-Reader" : "Target-Reader");

   auto Insert = [&](bool Insert, auto *Parent, auto *Child) {
     if (Insert)
       add(Parent, Child);
   };

   setCompileUnit(CompileUnit);
   add(Root, CompileUnit);

   // Add elements to CompileUnit.
   Insert(true, CompileUnit, IntegerType);
   Insert(true, CompileUnit, UnsignedType);
   Insert(true, CompileUnit, FunctionOne);
   Insert(IsTarget, CompileUnit, FunctionTwo);
   Insert(true, CompileUnit, GlobalVariable);
   Insert(true, CompileUnit, GlobalType);
   Insert(true, CompileUnit, Namespace);

   // Add elements to Namespace.
   Insert(true, Namespace, Aggregate);
   Insert(true, Namespace, Enumeration);
   Insert(IsReference, Namespace, TypeDefinitionOne);
   Insert(IsTarget, Namespace, TypeDefinitionTwo);

   // Add elements to FunctionOne.
   Insert(true, FunctionOne, ParameterOne);
   Insert(IsReference, FunctionOne, LocalVariable);
   Insert(true, FunctionOne, LocalType);
   Insert(true, FunctionOne, LineOne);
   Insert(true, FunctionOne, NestedScope);

   // Add elements to FunctionTwo.
   Insert(IsTarget, FunctionTwo, ParameterTwo);

   // Add elements to NestedScope.
   Insert(true, NestedScope, NestedVariable);
   Insert(true, NestedScope, NestedType);
   Insert(IsReference, NestedScope, LineTwo);
   Insert(true, NestedScope, InnerScope);

   // Add elements to Enumeration.
   Insert(true, Enumeration, EnumeratorOne);
   Insert(true, Enumeration, EnumeratorTwo);

   // Add elements to Aggregate.
   Insert(true, Aggregate, ClassMember);

   Insert(IsTarget, InnerScope, LineThree);
 }

 // Set initial values to logical elements.
 void ReaderTestCompare::initElements() {
   setFilename("LogicalElements.obj");

   Root->setFileFormatName("FileFormat");

   // Types.
   set(IntegerType, "int", 0x1000);
   set(UnsignedType, "unsigned", 0x1010);
   set(GlobalType, "GlobalType", 0x1020, 1020);
   set(LocalType, "LocalType", 0x1030, 1030);
   set(NestedType, "NestedType", 0x1040, 1040);

   set(TypeDefinitionOne, "INTEGER", 0x1050, 1050, IntegerType);
   set(TypeDefinitionTwo, "INT", 0x1060, 1060, TypeDefinitionOne);

   set(EnumeratorOne, "One", 0x1070, 1070);
   EnumeratorOne->setValue("Blue");

   set(EnumeratorTwo, "Two", 0x1080, 1080);
   EnumeratorTwo->setValue("Red");

   // Scopes.
   set(Aggregate, "Class", 0x2000, 2000);
   set(Enumeration, "Colors", 0x2010, 2010);
   set(FunctionOne, "FunctionOne", 0x2020, 2020, GlobalType);
   set(FunctionTwo, "FunctionTwo", 0x2030, 2030, GlobalType);
   set(Namespace, "Namespace", 0x2040, 2040);
   set(NestedScope, "", 0x2050, 2050);
   set(InnerScope, "", 0x2060, 2060);
   set(CompileUnit, "test.cpp", 0x2070, 2070);

   // Symbols.
   set(GlobalVariable, "GlobalVariable", 0x3000, 3000);
   set(LocalVariable, "LocalVariable", 0x3010, 3010, UnsignedType);
   set(ClassMember, "ClassMember", 0x3020, 3020, IntegerType);
   set(ParameterOne, "ParameterOne", 0x3030, 3030, UnsignedType);
   set(ParameterTwo, "ParameterTwo", 0x3040, 3040, UnsignedType);
   set(NestedVariable, "NestedVariable", 0x3050, 3050);

   // Lines.
   set(LineOne, "", 0x4000, 4000);
   set(LineTwo, "", 0x4010, 4010);
   set(LineThree, "", 0x4020, 4020);
 }

 // Compare the logical views.
 void compareReadersViews(ReaderTestCompare *ReferenceReader,
                          ReaderTestCompare *TargetReader) {
   LVCompare Compare(nulls());
   Error Err = Compare.execute(ReferenceReader, TargetReader);
   ASSERT_THAT_ERROR(std::move(Err), Succeeded());

   // Get comparison table.
   LVPassTable PassTable = Compare.getPassTable();
   ASSERT_EQ(PassTable.size(), 5u);

   LVReader *Reader;
   LVElement *Element;
   LVComparePass Pass;

   // Reference: Missing 'FunctionOne'
   std::tie(Reader, Element, Pass) = PassTable[0];
   EXPECT_EQ(Reader, ReferenceReader);
   EXPECT_EQ(Element, ReferenceReader->FunctionOne);
   EXPECT_EQ(Pass, LVComparePass::Missing);

   // Reference: Missing 'TypeDefinitionOne'
   std::tie(Reader, Element, Pass) = PassTable[1];
   EXPECT_EQ(Reader, ReferenceReader);
   EXPECT_EQ(Element, ReferenceReader->TypeDefinitionOne);
   EXPECT_EQ(Pass, LVComparePass::Missing);

   // Target: Added 'FunctionOne'
   std::tie(Reader, Element, Pass) = PassTable[2];
   EXPECT_EQ(Reader, TargetReader);
   EXPECT_EQ(Element, TargetReader->FunctionOne);
   EXPECT_EQ(Pass, LVComparePass::Added);

   // Target: Added 'FunctionTwo'
   std::tie(Reader, Element, Pass) = PassTable[3];
   EXPECT_EQ(Reader, TargetReader);
   EXPECT_EQ(Element, TargetReader->FunctionTwo);
   EXPECT_EQ(Pass, LVComparePass::Added);

   // Target: Added 'TypeDefinitionTwo'
   std::tie(Reader, Element, Pass) = PassTable[4];
   EXPECT_EQ(Reader, TargetReader);
   EXPECT_EQ(Element, TargetReader->TypeDefinitionTwo);
   EXPECT_EQ(Pass, LVComparePass::Added);
 }

 // Compare the logical elements.
 void compareReadersElements(ReaderTestCompare *ReferenceReader,
                             ReaderTestCompare *TargetReader) {
   LVCompare Compare(nulls());
   Error Err = Compare.execute(ReferenceReader, TargetReader);
   ASSERT_THAT_ERROR(std::move(Err), Succeeded());

   // Get comparison table.
   LVPassTable PassTable = Compare.getPassTable();
   ASSERT_EQ(PassTable.size(), 7u);

   LVReader *Reader;
   LVElement *Element;
   LVComparePass Pass;

   // Reference: Missing 'LocalVariable'
   std::tie(Reader, Element, Pass) = PassTable[0];
   EXPECT_EQ(Reader, ReferenceReader);
   EXPECT_EQ(Element, ReferenceReader->LocalVariable);
   EXPECT_EQ(Pass, LVComparePass::Missing);

   // Reference: Missing 'TypeDefinitionOne'
   std::tie(Reader, Element, Pass) = PassTable[1];
   EXPECT_EQ(Reader, ReferenceReader);
   EXPECT_EQ(Element, ReferenceReader->TypeDefinitionOne);
   EXPECT_EQ(Pass, LVComparePass::Missing);

   // Reference: Missing 'LineTwo'
   std::tie(Reader, Element, Pass) = PassTable[2];
   EXPECT_EQ(Reader, ReferenceReader);
   EXPECT_EQ(Element, ReferenceReader->LineTwo);
   EXPECT_EQ(Pass, LVComparePass::Missing);

   // Target: Added 'FunctionTwo'
   std::tie(Reader, Element, Pass) = PassTable[3];
   EXPECT_EQ(Reader, TargetReader);
   EXPECT_EQ(Element, TargetReader->FunctionTwo);
   EXPECT_EQ(Pass, LVComparePass::Added);

   // Target: Added 'ParameterTwo'
   std::tie(Reader, Element, Pass) = PassTable[4];
   EXPECT_EQ(Reader, TargetReader);
   EXPECT_EQ(Element, TargetReader->ParameterTwo);
   EXPECT_EQ(Pass, LVComparePass::Added);

   // Target: Added 'TypeDefinitionTwo'
   std::tie(Reader, Element, Pass) = PassTable[5];
   EXPECT_EQ(Reader, TargetReader);
   EXPECT_EQ(Element, TargetReader->TypeDefinitionTwo);
   EXPECT_EQ(Pass, LVComparePass::Added);

   // Target: Added 'LineThree'
   std::tie(Reader, Element, Pass) = PassTable[6];
   EXPECT_EQ(Reader, TargetReader);
   EXPECT_EQ(Element, TargetReader->LineThree);
   EXPECT_EQ(Pass, LVComparePass::Added);
 }

 TEST(LogicalViewTest, CompareElements) {
   ScopedPrinter W(outs());

   // Reader options.
   LVOptions ReaderOptions;
   ReaderOptions.setCompareLines();
   ReaderOptions.setCompareScopes();
   ReaderOptions.setCompareSymbols();
   ReaderOptions.setCompareTypes();

   // The next set-ups are very similar. The only difference is the
   // comparison type, which must be set before the readers are created.
   //   Views: setCompareContext()
   //   Elements: resetCompareContext()
   {
     // Compare the logical views as whole unit (--compare-context).
     ReaderOptions.setCompareContext();
     ReaderOptions.resolveDependencies();
     options().setOptions(&ReaderOptions);

     ReaderTestCompare ReferenceReader(W);
     ReferenceReader.createElements();
     ReferenceReader.addElements(/*IsReference=*/true, /*IsTarget=*/false);
     ReferenceReader.initElements();

     ReaderTestCompare TargetReader(W);
     TargetReader.createElements();
     TargetReader.addElements(/*IsReference=*/false, /*IsTarget=*/true);
     TargetReader.initElements();

     compareReadersViews(&ReferenceReader, &TargetReader);
   }
   {
     // Compare the logical elements.
     ReaderOptions.resetCompareContext();
     ReaderOptions.resolveDependencies();
     options().setOptions(&ReaderOptions);

     ReaderTestCompare ReferenceReader(W);
     ReferenceReader.createElements();
     ReferenceReader.addElements(/*IsReference=*/true, /*IsTarget=*/false);
     ReferenceReader.initElements();

     ReaderTestCompare TargetReader(W);
     TargetReader.createElements();
     TargetReader.addElements(/*IsReference=*/false, /*IsTarget=*/true);
     TargetReader.initElements();

     compareReadersElements(&ReferenceReader, &TargetReader);
   }
 }

 } // namespace
	//===- llvm/unittest/DebugInfo/LogicalView/CompareElementsTest.cpp --------===//
	//
	// 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/DebugInfo/LogicalView/Core/LVCompare.h"
	#include "llvm/DebugInfo/LogicalView/Core/LVLine.h"
	#include "llvm/DebugInfo/LogicalView/Core/LVReader.h"
	#include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
	#include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
	#include "llvm/DebugInfo/LogicalView/Core/LVType.h"
	#include "llvm/Support/ScopedPrinter.h"
	#include "llvm/Support/ToolOutputFile.h"
	#include "llvm/Testing/Support/Error.h"

	#include "gtest/gtest.h"

	using namespace llvm;
	using namespace llvm::logicalview;

	namespace {

	//===----------------------------------------------------------------------===//
	// Basic Reader functionality.
	class ReaderTestCompare : public LVReader {
	#define CREATE(VARIABLE, CREATE_FUNCTION, SET_FUNCTION) \
	VARIABLE = CREATE_FUNCTION(); \
	EXPECT_NE(VARIABLE, nullptr); \
	VARIABLE->SET_FUNCTION();

	public:
	// Types.
	LVType *IntegerType = nullptr;
	LVType *UnsignedType = nullptr;
	LVType *GlobalType = nullptr;
	LVType *LocalType = nullptr;
	LVType *NestedType = nullptr;
	LVTypeDefinition *TypeDefinitionOne = nullptr;
	LVTypeDefinition *TypeDefinitionTwo = nullptr;
	LVTypeEnumerator *EnumeratorOne = nullptr;
	LVTypeEnumerator *EnumeratorTwo = nullptr;

	// Scopes.
	LVScope *NestedScope = nullptr;
	LVScope *InnerScope = nullptr;
	LVScopeAggregate *Aggregate = nullptr;
	LVScopeEnumeration *Enumeration = nullptr;
	LVScopeFunction *FunctionOne = nullptr;
	LVScopeFunction *FunctionTwo = nullptr;
	LVScopeNamespace *Namespace = nullptr;

	// Symbols.
	LVSymbol *GlobalVariable = nullptr;
	LVSymbol *LocalVariable = nullptr;
	LVSymbol *ClassMember = nullptr;
	LVSymbol *NestedVariable = nullptr;
	LVSymbol *ParameterOne = nullptr;
	LVSymbol *ParameterTwo = nullptr;

	// Lines.
	LVLine *LineOne = nullptr;
	LVLine *LineTwo = nullptr;
	LVLine *LineThree = nullptr;

	protected:
	void add(LVScope Parent, LVElement Element);
	void set(LVElement *Element, StringRef Name, LVOffset Offset,
	uint32_t LineNumber = 0, LVElement *Type = nullptr);

	public:
	ReaderTestCompare(ScopedPrinter &W) : LVReader("", "", W) {
	setInstance(this);
	}

	Error createScopes() { return LVReader::createScopes(); }
	Error printScopes() { return LVReader::printScopes(); }

	void createElements();
	void addElements(bool IsReference, bool IsTarget);
	void initElements();
	};

	// Helper function to add a logical element to a given scope.
	void ReaderTestCompare::add(LVScope Parent, LVElement Child) {
	Parent->addElement(Child);
	EXPECT_EQ(Child->getParent(), Parent);
	EXPECT_EQ(Child->getLevel(), Parent->getLevel() + 1);
	}

	// Helper function to set the initial values for a given logical element.
	void ReaderTestCompare::set(LVElement *Element, StringRef Name, LVOffset Offset,
	uint32_t LineNumber, LVElement *Type) {
	Element->setName(Name);
	Element->setOffset(Offset);
	Element->setLineNumber(LineNumber);
	Element->setType(Type);
	}

	//===----------------------------------------------------------------------===//
	// Create the logical elements.
	void ReaderTestCompare::createElements() {
	// Create scope root.
	Error Err = createScopes();
	ASSERT_THAT_ERROR(std::move(Err), Succeeded());
	Root = getScopesRoot();
	ASSERT_NE(Root, nullptr);

	// Create the logical types.
	CREATE(IntegerType, createType, setIsBase);
	CREATE(UnsignedType, createType, setIsBase);
	CREATE(GlobalType, createType, setIsBase);
	CREATE(LocalType, createType, setIsBase);
	CREATE(NestedType, createType, setIsBase);
	CREATE(EnumeratorOne, createTypeEnumerator, setIsEnumerator);
	CREATE(EnumeratorTwo, createTypeEnumerator, setIsEnumerator);
	CREATE(TypeDefinitionOne, createTypeDefinition, setIsTypedef);
	CREATE(TypeDefinitionTwo, createTypeDefinition, setIsTypedef);

	// Create the logical scopes.
	CREATE(NestedScope, createScope, setIsLexicalBlock);
	CREATE(InnerScope, createScope, setIsLexicalBlock);
	CREATE(Aggregate, createScopeAggregate, setIsAggregate);
	CREATE(CompileUnit, createScopeCompileUnit, setIsCompileUnit);
	CREATE(Enumeration, createScopeEnumeration, setIsEnumeration);
	CREATE(FunctionOne, createScopeFunction, setIsFunction);
	CREATE(FunctionTwo, createScopeFunction, setIsFunction);
	CREATE(Namespace, createScopeNamespace, setIsNamespace);

	// Create the logical symbols.
	CREATE(GlobalVariable, createSymbol, setIsVariable);
	CREATE(LocalVariable, createSymbol, setIsVariable);
	CREATE(ClassMember, createSymbol, setIsMember);
	CREATE(NestedVariable, createSymbol, setIsVariable);
	CREATE(ParameterOne, createSymbol, setIsParameter);
	CREATE(ParameterTwo, createSymbol, setIsParameter);

	// Create the logical lines.
	CREATE(LineOne, createLine, setIsLineDebug);
	CREATE(LineTwo, createLine, setIsLineDebug);
	CREATE(LineThree, createLine, setIsLineDebug);
	}

	// Reference Reader: Target Reader:
	// ---------------------- ----------------------
	// Root Root
	// CompileUnit CompileUnit
	// IntegerType IntegerType
	// UnsignedType UnsignedType
	// FunctionOne FunctionOne
	// ParameterOne ParameterOne
	// LocalVariable ---
	// LocalType LocalType
	// LineOne LineOne
	// NestedScope NestedScope
	// NestedVariable NestedVariable
	// NestedType NestedType
	// LineTwo ---
	// InnerScope InnerScope
	// --- LineThree
	// --- FunctionTwo
	// --- ParameterTwo
	// GlobalVariable GlobalVariable
	// GlobalType GlobalType
	// Namespace Namespace
	// Aggregate Aggregate
	// ClassMember ClassMember
	// Enumeration Enumeration
	// EnumeratorOne EnumeratorOne
	// EnumeratorTwo EnumeratorTwo
	// TypeDefinitionOne ---
	// --- TypeDefinitionTwo

	// Create the logical view adding the created logical elements.
	void ReaderTestCompare::addElements(bool IsReference, bool IsTarget) {
	Root->setName(IsReference ? "Reference-Reader" : "Target-Reader");

	auto Insert = [&](bool Insert, auto Parent, auto Child) {
	if (Insert)
	add(Parent, Child);
	};

	setCompileUnit(CompileUnit);
	add(Root, CompileUnit);

	// Add elements to CompileUnit.
	Insert(true, CompileUnit, IntegerType);
	Insert(true, CompileUnit, UnsignedType);
	Insert(true, CompileUnit, FunctionOne);
	Insert(IsTarget, CompileUnit, FunctionTwo);
	Insert(true, CompileUnit, GlobalVariable);
	Insert(true, CompileUnit, GlobalType);
	Insert(true, CompileUnit, Namespace);

	// Add elements to Namespace.
	Insert(true, Namespace, Aggregate);
	Insert(true, Namespace, Enumeration);
	Insert(IsReference, Namespace, TypeDefinitionOne);
	Insert(IsTarget, Namespace, TypeDefinitionTwo);

	// Add elements to FunctionOne.
	Insert(true, FunctionOne, ParameterOne);
	Insert(IsReference, FunctionOne, LocalVariable);
	Insert(true, FunctionOne, LocalType);
	Insert(true, FunctionOne, LineOne);
	Insert(true, FunctionOne, NestedScope);

	// Add elements to FunctionTwo.
	Insert(IsTarget, FunctionTwo, ParameterTwo);

	// Add elements to NestedScope.
	Insert(true, NestedScope, NestedVariable);
	Insert(true, NestedScope, NestedType);
	Insert(IsReference, NestedScope, LineTwo);
	Insert(true, NestedScope, InnerScope);

	// Add elements to Enumeration.
	Insert(true, Enumeration, EnumeratorOne);
	Insert(true, Enumeration, EnumeratorTwo);

	// Add elements to Aggregate.
	Insert(true, Aggregate, ClassMember);

	Insert(IsTarget, InnerScope, LineThree);
	}

	// Set initial values to logical elements.
	void ReaderTestCompare::initElements() {
	setFilename("LogicalElements.obj");

	Root->setFileFormatName("FileFormat");

	// Types.
	set(IntegerType, "int", 0x1000);
	set(UnsignedType, "unsigned", 0x1010);
	set(GlobalType, "GlobalType", 0x1020, 1020);
	set(LocalType, "LocalType", 0x1030, 1030);
	set(NestedType, "NestedType", 0x1040, 1040);

	set(TypeDefinitionOne, "INTEGER", 0x1050, 1050, IntegerType);
	set(TypeDefinitionTwo, "INT", 0x1060, 1060, TypeDefinitionOne);

	set(EnumeratorOne, "One", 0x1070, 1070);
	EnumeratorOne->setValue("Blue");

	set(EnumeratorTwo, "Two", 0x1080, 1080);
	EnumeratorTwo->setValue("Red");

	// Scopes.
	set(Aggregate, "Class", 0x2000, 2000);
	set(Enumeration, "Colors", 0x2010, 2010);
	set(FunctionOne, "FunctionOne", 0x2020, 2020, GlobalType);
	set(FunctionTwo, "FunctionTwo", 0x2030, 2030, GlobalType);
	set(Namespace, "Namespace", 0x2040, 2040);
	set(NestedScope, "", 0x2050, 2050);
	set(InnerScope, "", 0x2060, 2060);
	set(CompileUnit, "test.cpp", 0x2070, 2070);

	// Symbols.
	set(GlobalVariable, "GlobalVariable", 0x3000, 3000);
	set(LocalVariable, "LocalVariable", 0x3010, 3010, UnsignedType);
	set(ClassMember, "ClassMember", 0x3020, 3020, IntegerType);
	set(ParameterOne, "ParameterOne", 0x3030, 3030, UnsignedType);
	set(ParameterTwo, "ParameterTwo", 0x3040, 3040, UnsignedType);
	set(NestedVariable, "NestedVariable", 0x3050, 3050);

	// Lines.
	set(LineOne, "", 0x4000, 4000);
	set(LineTwo, "", 0x4010, 4010);
	set(LineThree, "", 0x4020, 4020);
	}

	// Compare the logical views.
	void compareReadersViews(ReaderTestCompare *ReferenceReader,
	ReaderTestCompare *TargetReader) {
	LVCompare Compare(nulls());
	Error Err = Compare.execute(ReferenceReader, TargetReader);
	ASSERT_THAT_ERROR(std::move(Err), Succeeded());

	// Get comparison table.
	LVPassTable PassTable = Compare.getPassTable();
	ASSERT_EQ(PassTable.size(), 5u);

	LVReader *Reader;
	LVElement *Element;
	LVComparePass Pass;

	// Reference: Missing 'FunctionOne'
	std::tie(Reader, Element, Pass) = PassTable[0];
	EXPECT_EQ(Reader, ReferenceReader);
	EXPECT_EQ(Element, ReferenceReader->FunctionOne);
	EXPECT_EQ(Pass, LVComparePass::Missing);

	// Reference: Missing 'TypeDefinitionOne'
	std::tie(Reader, Element, Pass) = PassTable[1];
	EXPECT_EQ(Reader, ReferenceReader);
	EXPECT_EQ(Element, ReferenceReader->TypeDefinitionOne);
	EXPECT_EQ(Pass, LVComparePass::Missing);

	// Target: Added 'FunctionOne'
	std::tie(Reader, Element, Pass) = PassTable[2];
	EXPECT_EQ(Reader, TargetReader);
	EXPECT_EQ(Element, TargetReader->FunctionOne);
	EXPECT_EQ(Pass, LVComparePass::Added);

	// Target: Added 'FunctionTwo'
	std::tie(Reader, Element, Pass) = PassTable[3];
	EXPECT_EQ(Reader, TargetReader);
	EXPECT_EQ(Element, TargetReader->FunctionTwo);
	EXPECT_EQ(Pass, LVComparePass::Added);

	// Target: Added 'TypeDefinitionTwo'
	std::tie(Reader, Element, Pass) = PassTable[4];
	EXPECT_EQ(Reader, TargetReader);
	EXPECT_EQ(Element, TargetReader->TypeDefinitionTwo);
	EXPECT_EQ(Pass, LVComparePass::Added);
	}

	// Compare the logical elements.
	void compareReadersElements(ReaderTestCompare *ReferenceReader,
	ReaderTestCompare *TargetReader) {
	LVCompare Compare(nulls());
	Error Err = Compare.execute(ReferenceReader, TargetReader);
	ASSERT_THAT_ERROR(std::move(Err), Succeeded());

	// Get comparison table.
	LVPassTable PassTable = Compare.getPassTable();
	ASSERT_EQ(PassTable.size(), 7u);

	LVReader *Reader;
	LVElement *Element;
	LVComparePass Pass;

	// Reference: Missing 'LocalVariable'
	std::tie(Reader, Element, Pass) = PassTable[0];
	EXPECT_EQ(Reader, ReferenceReader);
	EXPECT_EQ(Element, ReferenceReader->LocalVariable);
	EXPECT_EQ(Pass, LVComparePass::Missing);

	// Reference: Missing 'TypeDefinitionOne'
	std::tie(Reader, Element, Pass) = PassTable[1];
	EXPECT_EQ(Reader, ReferenceReader);
	EXPECT_EQ(Element, ReferenceReader->TypeDefinitionOne);
	EXPECT_EQ(Pass, LVComparePass::Missing);

	// Reference: Missing 'LineTwo'
	std::tie(Reader, Element, Pass) = PassTable[2];
	EXPECT_EQ(Reader, ReferenceReader);
	EXPECT_EQ(Element, ReferenceReader->LineTwo);
	EXPECT_EQ(Pass, LVComparePass::Missing);

	// Target: Added 'FunctionTwo'
	std::tie(Reader, Element, Pass) = PassTable[3];
	EXPECT_EQ(Reader, TargetReader);
	EXPECT_EQ(Element, TargetReader->FunctionTwo);
	EXPECT_EQ(Pass, LVComparePass::Added);

	// Target: Added 'ParameterTwo'
	std::tie(Reader, Element, Pass) = PassTable[4];
	EXPECT_EQ(Reader, TargetReader);
	EXPECT_EQ(Element, TargetReader->ParameterTwo);
	EXPECT_EQ(Pass, LVComparePass::Added);

	// Target: Added 'TypeDefinitionTwo'
	std::tie(Reader, Element, Pass) = PassTable[5];
	EXPECT_EQ(Reader, TargetReader);
	EXPECT_EQ(Element, TargetReader->TypeDefinitionTwo);
	EXPECT_EQ(Pass, LVComparePass::Added);

	// Target: Added 'LineThree'
	std::tie(Reader, Element, Pass) = PassTable[6];
	EXPECT_EQ(Reader, TargetReader);
	EXPECT_EQ(Element, TargetReader->LineThree);
	EXPECT_EQ(Pass, LVComparePass::Added);
	}

	TEST(LogicalViewTest, CompareElements) {
	ScopedPrinter W(outs());

	// Reader options.
	LVOptions ReaderOptions;
	ReaderOptions.setCompareLines();
	ReaderOptions.setCompareScopes();
	ReaderOptions.setCompareSymbols();
	ReaderOptions.setCompareTypes();

	// The next set-ups are very similar. The only difference is the
	// comparison type, which must be set before the readers are created.
	// Views: setCompareContext()
	// Elements: resetCompareContext()
	{
	// Compare the logical views as whole unit (--compare-context).
	ReaderOptions.setCompareContext();
	ReaderOptions.resolveDependencies();
	options().setOptions(&ReaderOptions);

	ReaderTestCompare ReferenceReader(W);
	ReferenceReader.createElements();
	ReferenceReader.addElements(/IsReference=/true, /IsTarget=/false);
	ReferenceReader.initElements();

	ReaderTestCompare TargetReader(W);
	TargetReader.createElements();
	TargetReader.addElements(/IsReference=/false, /IsTarget=/true);
	TargetReader.initElements();

	compareReadersViews(&ReferenceReader, &TargetReader);
	}
	{
	// Compare the logical elements.
	ReaderOptions.resetCompareContext();
	ReaderOptions.resolveDependencies();
	options().setOptions(&ReaderOptions);

	ReaderTestCompare ReferenceReader(W);
	ReferenceReader.createElements();
	ReferenceReader.addElements(/IsReference=/true, /IsTarget=/false);
	ReferenceReader.initElements();

	ReaderTestCompare TargetReader(W);
	TargetReader.createElements();
	TargetReader.addElements(/IsReference=/false, /IsTarget=/true);
	TargetReader.initElements();

	compareReadersElements(&ReferenceReader, &TargetReader);
	}
	}

	} // namespace