unittests/InterfaceStub/ELFYAMLTest.cpp - llvm-project/llvm - Git at Google


            
            //===- llvm/unittests/TextAPI/YAMLTest.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/ADT/StringRef.h"

            
            #include "llvm/BinaryFormat/ELF.h"

            
            #include "llvm/InterfaceStub/IFSHandler.h"

            
            #include "llvm/InterfaceStub/IFSStub.h"

            
            #include "llvm/Support/Error.h"

            
            #include "llvm/Testing/Support/Error.h"

            
            #include "gtest/gtest.h"

            
            #include <string>


            using namespace llvm;

            
            using namespace llvm::ELF;

            
            using namespace llvm::ifs;


            void compareByLine(StringRef LHS, StringRef RHS) {

            
              StringRef Line1;

            
              StringRef Line2;

            
              while (LHS.size() > 0 && RHS.size() > 0) {

            
                std::tie(Line1, LHS) = LHS.split('\n');

            
                std::tie(Line2, RHS) = RHS.split('\n');

            
                // Comparing StringRef objects works, but has messy output when not equal.

            
                // Using STREQ on StringRef.data() doesn't work since these substrings are

            
                // not null terminated.

            
                // This is inefficient, but forces null terminated strings that can be

            
                // cleanly compared.

            
                EXPECT_STREQ(Line1.str().data(), Line2.str().data());

            
              }

            
            }


            TEST(ElfYamlTextAPI, YAMLReadableTBE) {

            
              const char Data[] = "--- !ifs-v1\n"

            
                                  "IfsVersion: 1.0\n"

            
                                  "Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: "

            
                                  "little, BitWidth: 64 }\n"

            
                                  "NeededLibs: [libc.so, libfoo.so, libbar.so]\n"

            
                                  "Symbols:\n"

            
                                  "  - { Name: foo, Type: Func, Undefined: true }\n"

            
                                  "...\n";

            
              Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);

            
              ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());

            
              std::unique_ptr<IFSStub> Stub = std::move(StubOrErr.get());

            
              EXPECT_NE(Stub.get(), nullptr);

            
              EXPECT_FALSE(Stub->SoName.has_value());

            
              EXPECT_TRUE(Stub->Target.Arch.has_value());

            
              EXPECT_EQ(*Stub->Target.Arch, (uint16_t)llvm::ELF::EM_X86_64);

            
              EXPECT_EQ(Stub->NeededLibs.size(), 3u);

            
              EXPECT_STREQ(Stub->NeededLibs[0].c_str(), "libc.so");

            
              EXPECT_STREQ(Stub->NeededLibs[1].c_str(), "libfoo.so");

            
              EXPECT_STREQ(Stub->NeededLibs[2].c_str(), "libbar.so");

            
            }


            TEST(ElfYamlTextAPI, YAMLReadsInvalidSymbols) {

            
              const char Data[] =

            
                  "--- !ifs-v1\n"

            
                  "IfsVersion: 1.0\n"

            
                  "SoName: test.so\n"

            
                  "Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, "

            
                  "BitWidth: 64 }\n"

            
                  "Symbols:\n"

            
                  "  - { Name: not, Type: File, Undefined: true, Size: 111, "

            
                  "Weak: true, Warning: \'All fields populated!\' }\n"

            
                  "...\n";

            
              Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);

            
              ASSERT_THAT_ERROR(

            
                  StubOrErr.takeError(),

            
                  FailedWithMessage("IFS symbol type for symbol 'not' is unsupported"));

            
            }


            TEST(ElfYamlTextAPI, YAMLReadsTBESymbols) {

            
              const char Data[] =

            
                  "--- !ifs-v1\n"

            
                  "IfsVersion: 1.0\n"

            
                  "SoName: test.so\n"

            
                  "Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, "

            
                  "BitWidth: 64 }\n"

            
                  "Symbols:\n"

            
                  "  - { Name: bar, Type: Object, Size: 42 }\n"

            
                  "  - { Name: baz, Type: TLS, Size: 3 }\n"

            
                  "  - { Name: foo, Type: Func, Warning: \"Deprecated!\" }\n"

            
                  "  - { Name: nor, Type: NoType, Undefined: true }\n"

            
                  "  - { Name: not, Type: NoType, Undefined: true, Size: 111, "

            
                  "Weak: true, Warning: \'All fields populated!\' }\n"

            
                  "...\n";

            
              Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);

            
              ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());

            
              std::unique_ptr<IFSStub> Stub = std::move(StubOrErr.get());

            
              EXPECT_NE(Stub.get(), nullptr);

            
              EXPECT_TRUE(Stub->SoName);

            
              EXPECT_STREQ(Stub->SoName->c_str(), "test.so");

            
              EXPECT_EQ(Stub->Symbols.size(), 5u);


              auto Iterator = Stub->Symbols.begin();

            
              IFSSymbol const &SymBar = *Iterator++;

            
              EXPECT_STREQ(SymBar.Name.c_str(), "bar");

            
              EXPECT_EQ(*SymBar.Size, 42u);

            
              EXPECT_EQ(SymBar.Type, IFSSymbolType::Object);

            
              EXPECT_FALSE(SymBar.Undefined);

            
              EXPECT_FALSE(SymBar.Weak);

            
              EXPECT_FALSE(SymBar.Warning);


              IFSSymbol const &SymBaz = *Iterator++;

            
              EXPECT_STREQ(SymBaz.Name.c_str(), "baz");

            
              EXPECT_EQ(*SymBaz.Size, 3u);

            
              EXPECT_EQ(SymBaz.Type, IFSSymbolType::TLS);

            
              EXPECT_FALSE(SymBaz.Undefined);

            
              EXPECT_FALSE(SymBaz.Weak);

            
              EXPECT_FALSE(SymBaz.Warning.has_value());


              IFSSymbol const &SymFoo = *Iterator++;

            
              EXPECT_STREQ(SymFoo.Name.c_str(), "foo");

            
              EXPECT_FALSE(SymFoo.Size.has_value());

            
              EXPECT_EQ(SymFoo.Type, IFSSymbolType::Func);

            
              EXPECT_FALSE(SymFoo.Undefined);

            
              EXPECT_FALSE(SymFoo.Weak);

            
              EXPECT_TRUE(SymFoo.Warning.has_value());

            
              EXPECT_STREQ(SymFoo.Warning->c_str(), "Deprecated!");


              IFSSymbol const &SymNor = *Iterator++;

            
              EXPECT_STREQ(SymNor.Name.c_str(), "nor");

            
              EXPECT_FALSE(SymNor.Size.has_value());

            
              EXPECT_EQ(SymNor.Type, IFSSymbolType::NoType);

            
              EXPECT_TRUE(SymNor.Undefined);

            
              EXPECT_FALSE(SymNor.Weak);

            
              EXPECT_FALSE(SymNor.Warning.has_value());


              IFSSymbol const &SymNot = *Iterator++;

            
              EXPECT_STREQ(SymNot.Name.c_str(), "not");

            
              EXPECT_EQ(*SymNot.Size, 111u);

            
              EXPECT_EQ(SymNot.Type, IFSSymbolType::NoType);

            
              EXPECT_TRUE(SymNot.Undefined);

            
              EXPECT_TRUE(SymNot.Weak);

            
              EXPECT_TRUE(SymNot.Warning);

            
              EXPECT_STREQ(SymNot.Warning->c_str(), "All fields populated!");

            
            }


            TEST(ElfYamlTextAPI, YAMLReadsNoTBESyms) {

            
              const char Data[] = "--- !ifs-v1\n"

            
                                  "IfsVersion: 1.0\n"

            
                                  "SoName: test.so\n"

            
                                  "Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: "

            
                                  "little, BitWidth: 64 }\n"

            
                                  "Symbols: []\n"

            
                                  "...\n";

            
              Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);

            
              ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());

            
              std::unique_ptr<IFSStub> Stub = std::move(StubOrErr.get());

            
              EXPECT_NE(Stub.get(), nullptr);

            
              EXPECT_EQ(0u, Stub->Symbols.size());

            
            }


            TEST(ElfYamlTextAPI, YAMLUnreadableTBE) {

            
              // Can't read: wrong format/version.

            
              const char Data[] = "--- !tapi-tbz\n"

            
                                  "IfsVersion: z.3\n"

            
                                  "SoName: test.so\n"

            
                                  "Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: "

            
                                  "little, BitWidth: 64 }\n"

            
                                  "Symbols:\n"

            
                                  "  foo: { Type: Func, Undefined: true }\n";

            
              Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);

            
              ASSERT_THAT_ERROR(StubOrErr.takeError(), Failed());

            
            }


            TEST(ElfYamlTextAPI, YAMLUnsupportedVersion) {

            
              const char Data[] = "--- !ifs-v1\n"

            
                                  "IfsVersion: 9.9.9\n"

            
                                  "SoName: test.so\n"

            
                                  "Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: "

            
                                  "little, BitWidth: 64 }\n"

            
                                  "Symbols: []\n"

            
                                  "...\n";

            
              Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);

            
              std::string ErrorMessage = toString(StubOrErr.takeError());

            
              EXPECT_EQ("IFS version 9.9.9 is unsupported.", ErrorMessage);

            
            }


            TEST(ElfYamlTextAPI, YAMLWritesTBESymbols) {

            
              const char Expected[] =

            
                  "--- !ifs-v1\n"

            
                  "IfsVersion:      1.0\n"

            
                  "Target:          { ObjectFormat: ELF, Arch: AArch64, Endianness: "

            
                  "little, BitWidth: 64 }\n"

            
                  "Symbols:\n"

            
                  "  - { Name: bar, Type: Func, Weak: true }\n"

            
                  "  - { Name: foo, Type: NoType, Size: 99, Warning: Does nothing }\n"

            
                  "  - { Name: nor, Type: Func, Undefined: true }\n"

            
                  "  - { Name: not, Type: Unknown, Size: 12345678901234 }\n"

            
                  "...\n";

            
              IFSStub Stub;

            
              Stub.IfsVersion = VersionTuple(1, 0);

            
              Stub.Target.Arch = ELF::EM_AARCH64;

            
              Stub.Target.BitWidth = IFSBitWidthType::IFS64;

            
              Stub.Target.Endianness = IFSEndiannessType::Little;

            
              Stub.Target.ObjectFormat = "ELF";


              IFSSymbol SymBar("bar");

            
              SymBar.Size = 128u;

            
              SymBar.Type = IFSSymbolType::Func;

            
              SymBar.Undefined = false;

            
              SymBar.Weak = true;


              IFSSymbol SymFoo("foo");

            
              SymFoo.Size = 99u;

            
              SymFoo.Type = IFSSymbolType::NoType;

            
              SymFoo.Undefined = false;

            
              SymFoo.Weak = false;

            
              SymFoo.Warning = "Does nothing";


              IFSSymbol SymNor("nor");

            
              SymNor.Size = 1234u;

            
              SymNor.Type = IFSSymbolType::Func;

            
              SymNor.Undefined = true;

            
              SymNor.Weak = false;


              IFSSymbol SymNot("not");

            
              SymNot.Size = 12345678901234u;

            
              SymNot.Type = IFSSymbolType::Unknown;

            
              SymNot.Undefined = false;

            
              SymNot.Weak = false;


              // Symbol order is preserved instead of being sorted.

            
              Stub.Symbols.push_back(SymBar);

            
              Stub.Symbols.push_back(SymFoo);

            
              Stub.Symbols.push_back(SymNor);

            
              Stub.Symbols.push_back(SymNot);


              // Ensure move constructor works as expected.

            
              IFSStub Moved = std::move(Stub);


              std::string Result;

            
              raw_string_ostream OS(Result);

            
              ASSERT_THAT_ERROR(writeIFSToOutputStream(OS, Moved), Succeeded());

            
              compareByLine(Result.c_str(), Expected);

            
            }


            TEST(ElfYamlTextAPI, YAMLWritesNoTBESyms) {

            
              const char Expected[] = "--- !ifs-v1\n"

            
                                      "IfsVersion:      1.0\n"

            
                                      "SoName:          nosyms.so\n"

            
                                      "Target:          { ObjectFormat: ELF, Arch: x86_64, "

            
                                      "Endianness: little, BitWidth: 64 }\n"

            
                                      "NeededLibs:\n"

            
                                      "  - libc.so\n"

            
                                      "  - libfoo.so\n"

            
                                      "  - libbar.so\n"

            
                                      "Symbols:         []\n"

            
                                      "...\n";

            
              IFSStub Stub;

            
              Stub.IfsVersion = VersionTuple(1, 0);

            
              Stub.SoName = "nosyms.so";

            
              Stub.Target.Arch = ELF::EM_X86_64;

            
              Stub.Target.BitWidth = IFSBitWidthType::IFS64;

            
              Stub.Target.Endianness = IFSEndiannessType::Little;

            
              Stub.Target.ObjectFormat = "ELF";

            
              Stub.NeededLibs.push_back("libc.so");

            
              Stub.NeededLibs.push_back("libfoo.so");

            
              Stub.NeededLibs.push_back("libbar.so");


              std::string Result;

            
              raw_string_ostream OS(Result);

            
              ASSERT_THAT_ERROR(writeIFSToOutputStream(OS, Stub), Succeeded());

            
              compareByLine(Result.c_str(), Expected);

            
            }
	//===- llvm/unittests/TextAPI/YAMLTest.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/ADT/StringRef.h"
	#include "llvm/BinaryFormat/ELF.h"
	#include "llvm/InterfaceStub/IFSHandler.h"
	#include "llvm/InterfaceStub/IFSStub.h"
	#include "llvm/Support/Error.h"
	#include "llvm/Testing/Support/Error.h"
	#include "gtest/gtest.h"
	#include <string>

	using namespace llvm;
	using namespace llvm::ELF;
	using namespace llvm::ifs;

	void compareByLine(StringRef LHS, StringRef RHS) {
	StringRef Line1;
	StringRef Line2;
	while (LHS.size() > 0 && RHS.size() > 0) {
	std::tie(Line1, LHS) = LHS.split('\n');
	std::tie(Line2, RHS) = RHS.split('\n');
	// Comparing StringRef objects works, but has messy output when not equal.
	// Using STREQ on StringRef.data() doesn't work since these substrings are
	// not null terminated.
	// This is inefficient, but forces null terminated strings that can be
	// cleanly compared.
	EXPECT_STREQ(Line1.str().data(), Line2.str().data());
	}
	}

	TEST(ElfYamlTextAPI, YAMLReadableTBE) {
	const char Data[] = "--- !ifs-v1\n"
	"IfsVersion: 1.0\n"
	"Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: "
	"little, BitWidth: 64 }\n"
	"NeededLibs: [libc.so, libfoo.so, libbar.so]\n"
	"Symbols:\n"
	" - { Name: foo, Type: Func, Undefined: true }\n"
	"...\n";
	Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);
	ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
	std::unique_ptr<IFSStub> Stub = std::move(StubOrErr.get());
	EXPECT_NE(Stub.get(), nullptr);
	EXPECT_FALSE(Stub->SoName.has_value());
	EXPECT_TRUE(Stub->Target.Arch.has_value());
	EXPECT_EQ(*Stub->Target.Arch, (uint16_t)llvm::ELF::EM_X86_64);
	EXPECT_EQ(Stub->NeededLibs.size(), 3u);
	EXPECT_STREQ(Stub->NeededLibs[0].c_str(), "libc.so");
	EXPECT_STREQ(Stub->NeededLibs[1].c_str(), "libfoo.so");
	EXPECT_STREQ(Stub->NeededLibs[2].c_str(), "libbar.so");
	}

	TEST(ElfYamlTextAPI, YAMLReadsInvalidSymbols) {
	const char Data[] =
	"--- !ifs-v1\n"
	"IfsVersion: 1.0\n"
	"SoName: test.so\n"
	"Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, "
	"BitWidth: 64 }\n"
	"Symbols:\n"
	" - { Name: not, Type: File, Undefined: true, Size: 111, "
	"Weak: true, Warning: \'All fields populated!\' }\n"
	"...\n";
	Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);
	ASSERT_THAT_ERROR(
	StubOrErr.takeError(),
	FailedWithMessage("IFS symbol type for symbol 'not' is unsupported"));
	}

	TEST(ElfYamlTextAPI, YAMLReadsTBESymbols) {
	const char Data[] =
	"--- !ifs-v1\n"
	"IfsVersion: 1.0\n"
	"SoName: test.so\n"
	"Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, "
	"BitWidth: 64 }\n"
	"Symbols:\n"
	" - { Name: bar, Type: Object, Size: 42 }\n"
	" - { Name: baz, Type: TLS, Size: 3 }\n"
	" - { Name: foo, Type: Func, Warning: \"Deprecated!\" }\n"
	" - { Name: nor, Type: NoType, Undefined: true }\n"
	" - { Name: not, Type: NoType, Undefined: true, Size: 111, "
	"Weak: true, Warning: \'All fields populated!\' }\n"
	"...\n";
	Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);
	ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
	std::unique_ptr<IFSStub> Stub = std::move(StubOrErr.get());
	EXPECT_NE(Stub.get(), nullptr);
	EXPECT_TRUE(Stub->SoName);
	EXPECT_STREQ(Stub->SoName->c_str(), "test.so");
	EXPECT_EQ(Stub->Symbols.size(), 5u);

	auto Iterator = Stub->Symbols.begin();
	IFSSymbol const &SymBar = *Iterator++;
	EXPECT_STREQ(SymBar.Name.c_str(), "bar");
	EXPECT_EQ(*SymBar.Size, 42u);
	EXPECT_EQ(SymBar.Type, IFSSymbolType::Object);
	EXPECT_FALSE(SymBar.Undefined);
	EXPECT_FALSE(SymBar.Weak);
	EXPECT_FALSE(SymBar.Warning);

	IFSSymbol const &SymBaz = *Iterator++;
	EXPECT_STREQ(SymBaz.Name.c_str(), "baz");
	EXPECT_EQ(*SymBaz.Size, 3u);
	EXPECT_EQ(SymBaz.Type, IFSSymbolType::TLS);
	EXPECT_FALSE(SymBaz.Undefined);
	EXPECT_FALSE(SymBaz.Weak);
	EXPECT_FALSE(SymBaz.Warning.has_value());

	IFSSymbol const &SymFoo = *Iterator++;
	EXPECT_STREQ(SymFoo.Name.c_str(), "foo");
	EXPECT_FALSE(SymFoo.Size.has_value());
	EXPECT_EQ(SymFoo.Type, IFSSymbolType::Func);
	EXPECT_FALSE(SymFoo.Undefined);
	EXPECT_FALSE(SymFoo.Weak);
	EXPECT_TRUE(SymFoo.Warning.has_value());
	EXPECT_STREQ(SymFoo.Warning->c_str(), "Deprecated!");

	IFSSymbol const &SymNor = *Iterator++;
	EXPECT_STREQ(SymNor.Name.c_str(), "nor");
	EXPECT_FALSE(SymNor.Size.has_value());
	EXPECT_EQ(SymNor.Type, IFSSymbolType::NoType);
	EXPECT_TRUE(SymNor.Undefined);
	EXPECT_FALSE(SymNor.Weak);
	EXPECT_FALSE(SymNor.Warning.has_value());

	IFSSymbol const &SymNot = *Iterator++;
	EXPECT_STREQ(SymNot.Name.c_str(), "not");
	EXPECT_EQ(*SymNot.Size, 111u);
	EXPECT_EQ(SymNot.Type, IFSSymbolType::NoType);
	EXPECT_TRUE(SymNot.Undefined);
	EXPECT_TRUE(SymNot.Weak);
	EXPECT_TRUE(SymNot.Warning);
	EXPECT_STREQ(SymNot.Warning->c_str(), "All fields populated!");
	}

	TEST(ElfYamlTextAPI, YAMLReadsNoTBESyms) {
	const char Data[] = "--- !ifs-v1\n"
	"IfsVersion: 1.0\n"
	"SoName: test.so\n"
	"Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: "
	"little, BitWidth: 64 }\n"
	"Symbols: []\n"
	"...\n";
	Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);
	ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
	std::unique_ptr<IFSStub> Stub = std::move(StubOrErr.get());
	EXPECT_NE(Stub.get(), nullptr);
	EXPECT_EQ(0u, Stub->Symbols.size());
	}

	TEST(ElfYamlTextAPI, YAMLUnreadableTBE) {
	// Can't read: wrong format/version.
	const char Data[] = "--- !tapi-tbz\n"
	"IfsVersion: z.3\n"
	"SoName: test.so\n"
	"Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: "
	"little, BitWidth: 64 }\n"
	"Symbols:\n"
	" foo: { Type: Func, Undefined: true }\n";
	Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);
	ASSERT_THAT_ERROR(StubOrErr.takeError(), Failed());
	}

	TEST(ElfYamlTextAPI, YAMLUnsupportedVersion) {
	const char Data[] = "--- !ifs-v1\n"
	"IfsVersion: 9.9.9\n"
	"SoName: test.so\n"
	"Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: "
	"little, BitWidth: 64 }\n"
	"Symbols: []\n"
	"...\n";
	Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);
	std::string ErrorMessage = toString(StubOrErr.takeError());
	EXPECT_EQ("IFS version 9.9.9 is unsupported.", ErrorMessage);
	}

	TEST(ElfYamlTextAPI, YAMLWritesTBESymbols) {
	const char Expected[] =
	"--- !ifs-v1\n"
	"IfsVersion: 1.0\n"
	"Target: { ObjectFormat: ELF, Arch: AArch64, Endianness: "
	"little, BitWidth: 64 }\n"
	"Symbols:\n"
	" - { Name: bar, Type: Func, Weak: true }\n"
	" - { Name: foo, Type: NoType, Size: 99, Warning: Does nothing }\n"
	" - { Name: nor, Type: Func, Undefined: true }\n"
	" - { Name: not, Type: Unknown, Size: 12345678901234 }\n"
	"...\n";
	IFSStub Stub;
	Stub.IfsVersion = VersionTuple(1, 0);
	Stub.Target.Arch = ELF::EM_AARCH64;
	Stub.Target.BitWidth = IFSBitWidthType::IFS64;
	Stub.Target.Endianness = IFSEndiannessType::Little;
	Stub.Target.ObjectFormat = "ELF";

	IFSSymbol SymBar("bar");
	SymBar.Size = 128u;
	SymBar.Type = IFSSymbolType::Func;
	SymBar.Undefined = false;
	SymBar.Weak = true;

	IFSSymbol SymFoo("foo");
	SymFoo.Size = 99u;
	SymFoo.Type = IFSSymbolType::NoType;
	SymFoo.Undefined = false;
	SymFoo.Weak = false;
	SymFoo.Warning = "Does nothing";

	IFSSymbol SymNor("nor");
	SymNor.Size = 1234u;
	SymNor.Type = IFSSymbolType::Func;
	SymNor.Undefined = true;
	SymNor.Weak = false;

	IFSSymbol SymNot("not");
	SymNot.Size = 12345678901234u;
	SymNot.Type = IFSSymbolType::Unknown;
	SymNot.Undefined = false;
	SymNot.Weak = false;

	// Symbol order is preserved instead of being sorted.
	Stub.Symbols.push_back(SymBar);
	Stub.Symbols.push_back(SymFoo);
	Stub.Symbols.push_back(SymNor);
	Stub.Symbols.push_back(SymNot);

	// Ensure move constructor works as expected.
	IFSStub Moved = std::move(Stub);

	std::string Result;
	raw_string_ostream OS(Result);
	ASSERT_THAT_ERROR(writeIFSToOutputStream(OS, Moved), Succeeded());
	compareByLine(Result.c_str(), Expected);
	}

	TEST(ElfYamlTextAPI, YAMLWritesNoTBESyms) {
	const char Expected[] = "--- !ifs-v1\n"
	"IfsVersion: 1.0\n"
	"SoName: nosyms.so\n"
	"Target: { ObjectFormat: ELF, Arch: x86_64, "
	"Endianness: little, BitWidth: 64 }\n"
	"NeededLibs:\n"
	" - libc.so\n"
	" - libfoo.so\n"
	" - libbar.so\n"
	"Symbols: []\n"
	"...\n";
	IFSStub Stub;
	Stub.IfsVersion = VersionTuple(1, 0);
	Stub.SoName = "nosyms.so";
	Stub.Target.Arch = ELF::EM_X86_64;
	Stub.Target.BitWidth = IFSBitWidthType::IFS64;
	Stub.Target.Endianness = IFSEndiannessType::Little;
	Stub.Target.ObjectFormat = "ELF";
	Stub.NeededLibs.push_back("libc.so");
	Stub.NeededLibs.push_back("libfoo.so");
	Stub.NeededLibs.push_back("libbar.so");

	std::string Result;
	raw_string_ostream OS(Result);
	ASSERT_THAT_ERROR(writeIFSToOutputStream(OS, Stub), Succeeded());
	compareByLine(Result.c_str(), Expected);
	}