unittests/TextAPI/ELFYAMLTest.cpp - 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/TextAPI/ELF/ELFStub.h"
 #include "llvm/TextAPI/ELF/TBEHandler.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::elfabi;

 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[] = "--- !tapi-tbe\n"
                       "TbeVersion: 1.0\n"
                       "Arch: x86_64\n"
                       "NeededLibs: [libc.so, libfoo.so, libbar.so]\n"
                       "Symbols:\n"
                       "  foo: { Type: Func, Undefined: true }\n"
                       "...\n";
   Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
   std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get());
   EXPECT_NE(Stub.get(), nullptr);
   EXPECT_FALSE(Stub->SoName.hasValue());
   EXPECT_EQ(Stub->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, YAMLReadsTBESymbols) {
   const char Data[] = "--- !tapi-tbe\n"
                       "TbeVersion: 1.0\n"
                       "SoName: test.so\n"
                       "Arch: x86_64\n"
                       "Symbols:\n"
                       "  bar: { Type: Object, Size: 42 }\n"
                       "  baz: { Type: TLS, Size: 3 }\n"
                       "  foo: { Type: Func, Warning: \"Deprecated!\" }\n"
                       "  nor: { Type: NoType, Undefined: true }\n"
                       "  not: { Type: File, Undefined: true, Size: 111, "
                       "Weak: true, Warning: \'All fields populated!\' }\n"
                       "...\n";
   Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
   std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get());
   EXPECT_NE(Stub.get(), nullptr);
   EXPECT_TRUE(Stub->SoName.hasValue());
   EXPECT_STREQ(Stub->SoName->c_str(), "test.so");
   EXPECT_EQ(Stub->Symbols.size(), 5u);

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

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

   ELFSymbol const &SymFoo = *Iterator++;
   EXPECT_STREQ(SymFoo.Name.c_str(), "foo");
   EXPECT_EQ(SymFoo.Size, 0u);
   EXPECT_EQ(SymFoo.Type, ELFSymbolType::Func);
   EXPECT_FALSE(SymFoo.Undefined);
   EXPECT_FALSE(SymFoo.Weak);
   EXPECT_TRUE(SymFoo.Warning.hasValue());
   EXPECT_STREQ(SymFoo.Warning->c_str(), "Deprecated!");

   ELFSymbol const &SymNor = *Iterator++;
   EXPECT_STREQ(SymNor.Name.c_str(), "nor");
   EXPECT_EQ(SymNor.Size, 0u);
   EXPECT_EQ(SymNor.Type, ELFSymbolType::NoType);
   EXPECT_TRUE(SymNor.Undefined);
   EXPECT_FALSE(SymNor.Weak);
   EXPECT_FALSE(SymNor.Warning.hasValue());

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

 TEST(ElfYamlTextAPI, YAMLReadsNoTBESyms) {
   const char Data[] = "--- !tapi-tbe\n"
                       "TbeVersion: 1.0\n"
                       "SoName: test.so\n"
                       "Arch: x86_64\n"
                       "Symbols: {}\n"
                       "...\n";
   Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
   std::unique_ptr<ELFStub> 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"
                       "TbeVersion: z.3\n"
                       "SoName: test.so\n"
                       "Arch: x86_64\n"
                       "Symbols:\n"
                       "  foo: { Type: Func, Undefined: true }\n";
   Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Failed());
 }

 TEST(ElfYamlTextAPI, YAMLWritesTBESymbols) {
   const char Expected[] =
       "--- !tapi-tbe\n"
       "TbeVersion:      1.0\n"
       "Arch:            AArch64\n"
       "Symbols:         \n"
       "  bar:             { Type: Func, Weak: true }\n"
       "  foo:             { Type: NoType, Size: 99, Warning: Does nothing }\n"
       "  nor:             { Type: Func, Undefined: true }\n"
       "  not:             { Type: Unknown, Size: 12345678901234 }\n"
       "...\n";
   ELFStub Stub;
   Stub.TbeVersion = VersionTuple(1, 0);
   Stub.Arch = ELF::EM_AARCH64;

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

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

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

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

   // Deliberately not in order to check that result is sorted.
   Stub.Symbols.insert(SymNot);
   Stub.Symbols.insert(SymBar);
   Stub.Symbols.insert(SymFoo);
   Stub.Symbols.insert(SymNor);

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

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

 TEST(ElfYamlTextAPI, YAMLWritesNoTBESyms) {
   const char Expected[] = "--- !tapi-tbe\n"
                           "TbeVersion:      1.0\n"
                           "SoName:          nosyms.so\n"
                           "Arch:            x86_64\n"
                           "NeededLibs:      \n"
                           "  - libc.so\n"
                           "  - libfoo.so\n"
                           "  - libbar.so\n"
                           "Symbols:         {}\n"
                           "...\n";
   ELFStub Stub;
   Stub.TbeVersion = VersionTuple(1, 0);
   Stub.SoName = "nosyms.so";
   Stub.Arch = ELF::EM_X86_64;
   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(writeTBEToOutputStream(OS, Stub), Succeeded());
   Result = OS.str();
   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/TextAPI/ELF/ELFStub.h"
	#include "llvm/TextAPI/ELF/TBEHandler.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::elfabi;

	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[] = "--- !tapi-tbe\n"
	"TbeVersion: 1.0\n"
	"Arch: x86_64\n"
	"NeededLibs: [libc.so, libfoo.so, libbar.so]\n"
	"Symbols:\n"
	" foo: { Type: Func, Undefined: true }\n"
	"...\n";
	Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
	ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
	std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get());
	EXPECT_NE(Stub.get(), nullptr);
	EXPECT_FALSE(Stub->SoName.hasValue());
	EXPECT_EQ(Stub->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, YAMLReadsTBESymbols) {
	const char Data[] = "--- !tapi-tbe\n"
	"TbeVersion: 1.0\n"
	"SoName: test.so\n"
	"Arch: x86_64\n"
	"Symbols:\n"
	" bar: { Type: Object, Size: 42 }\n"
	" baz: { Type: TLS, Size: 3 }\n"
	" foo: { Type: Func, Warning: \"Deprecated!\" }\n"
	" nor: { Type: NoType, Undefined: true }\n"
	" not: { Type: File, Undefined: true, Size: 111, "
	"Weak: true, Warning: \'All fields populated!\' }\n"
	"...\n";
	Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
	ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
	std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get());
	EXPECT_NE(Stub.get(), nullptr);
	EXPECT_TRUE(Stub->SoName.hasValue());
	EXPECT_STREQ(Stub->SoName->c_str(), "test.so");
	EXPECT_EQ(Stub->Symbols.size(), 5u);

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

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

	ELFSymbol const &SymFoo = *Iterator++;
	EXPECT_STREQ(SymFoo.Name.c_str(), "foo");
	EXPECT_EQ(SymFoo.Size, 0u);
	EXPECT_EQ(SymFoo.Type, ELFSymbolType::Func);
	EXPECT_FALSE(SymFoo.Undefined);
	EXPECT_FALSE(SymFoo.Weak);
	EXPECT_TRUE(SymFoo.Warning.hasValue());
	EXPECT_STREQ(SymFoo.Warning->c_str(), "Deprecated!");

	ELFSymbol const &SymNor = *Iterator++;
	EXPECT_STREQ(SymNor.Name.c_str(), "nor");
	EXPECT_EQ(SymNor.Size, 0u);
	EXPECT_EQ(SymNor.Type, ELFSymbolType::NoType);
	EXPECT_TRUE(SymNor.Undefined);
	EXPECT_FALSE(SymNor.Weak);
	EXPECT_FALSE(SymNor.Warning.hasValue());

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

	TEST(ElfYamlTextAPI, YAMLReadsNoTBESyms) {
	const char Data[] = "--- !tapi-tbe\n"
	"TbeVersion: 1.0\n"
	"SoName: test.so\n"
	"Arch: x86_64\n"
	"Symbols: {}\n"
	"...\n";
	Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
	ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
	std::unique_ptr<ELFStub> 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"
	"TbeVersion: z.3\n"
	"SoName: test.so\n"
	"Arch: x86_64\n"
	"Symbols:\n"
	" foo: { Type: Func, Undefined: true }\n";
	Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
	ASSERT_THAT_ERROR(StubOrErr.takeError(), Failed());
	}

	TEST(ElfYamlTextAPI, YAMLWritesTBESymbols) {
	const char Expected[] =
	"--- !tapi-tbe\n"
	"TbeVersion: 1.0\n"
	"Arch: AArch64\n"
	"Symbols: \n"
	" bar: { Type: Func, Weak: true }\n"
	" foo: { Type: NoType, Size: 99, Warning: Does nothing }\n"
	" nor: { Type: Func, Undefined: true }\n"
	" not: { Type: Unknown, Size: 12345678901234 }\n"
	"...\n";
	ELFStub Stub;
	Stub.TbeVersion = VersionTuple(1, 0);
	Stub.Arch = ELF::EM_AARCH64;

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

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

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

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

	// Deliberately not in order to check that result is sorted.
	Stub.Symbols.insert(SymNot);
	Stub.Symbols.insert(SymBar);
	Stub.Symbols.insert(SymFoo);
	Stub.Symbols.insert(SymNor);

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

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

	TEST(ElfYamlTextAPI, YAMLWritesNoTBESyms) {
	const char Expected[] = "--- !tapi-tbe\n"
	"TbeVersion: 1.0\n"
	"SoName: nosyms.so\n"
	"Arch: x86_64\n"
	"NeededLibs: \n"
	" - libc.so\n"
	" - libfoo.so\n"
	" - libbar.so\n"
	"Symbols: {}\n"
	"...\n";
	ELFStub Stub;
	Stub.TbeVersion = VersionTuple(1, 0);
	Stub.SoName = "nosyms.so";
	Stub.Arch = ELF::EM_X86_64;
	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(writeTBEToOutputStream(OS, Stub), Succeeded());
	Result = OS.str();
	compareByLine(Result.c_str(), Expected);
	}