Tests.cpp File Reference

Unit tests for Bartleby. More...

#include "Bartleby/Bartleby.h"
#include "Bartleby-c/Bartleby.h"
#include "llvm/ADT/Triple.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Object/Binary.h"
#include "llvm/ObjectYAML/yaml2obj.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/SmallVectorMemoryBuffer.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/YAMLParser.h"
#include "llvm/Support/YAMLTraits.h"
#include <unistd.h>
#include "gtest/gtest.h"

Macros
#define	TEST_DATA_BASE_DIR   "bartleby/tests/Bartleby/testdata/yaml"
	Base directory for test data based on yaml files.
#define	ASSERT_SYM_RESOLVE(_b_, _name_)
	Resolves a symbol in the map of symbols.
#define	ASSERT_SYM_GLOBALNESS(_b_, _name_, _exp_)
	Asserts the globalness of a symbol.
#define	ASSERT_SYM_LOCAL(_b_, _name_)    ASSERT_SYM_GLOBALNESS((_b_), (_name_), false)
	Asserts that a symbol is local.
#define	ASSERT_SYM_GLOBAL(_b_, _name_)    ASSERT_SYM_GLOBALNESS((_b_), (_name_), true)
	Asserts that a symbol is local.
#define	ASSERT_SYM_DEFINEDNESS(_b_, _name_, _exp_)
	Asserts the definedness of a symbol.
#define	ASSERT_SYM_UNDEFINED(_b_, _name_)    ASSERT_SYM_DEFINEDNESS((_b_), (_name_), false)
	Asserts that a symbol is undefined.
#define	ASSERT_SYM_DEFINED(_b_, _name_)    ASSERT_SYM_DEFINEDNESS((_b_), (_name_), true)
	Asserts that a symbol is defined.
#define	ASSERT_SYM_OVERWRITTEN(_b_, _name_, _exp_)
	Asserts the overwrittenness of a symbol.
#define	ASSERT_SYM_WILL_BE_RENAMED(_b_, _name_)    ASSERT_SYM_OVERWRITTEN((_b_), (_name_), true)
	Asserts that a symbol name will be overwritten.
#define	ASSERT_SYM_WILL_NOT_BE_RENAMED(_b_, _name_)    ASSERT_SYM_OVERWRITTEN((_b_), (_name_), false)
	Asserts that a symbol name will NOT be overwritten.

Functions
	TEST (BartleByObjectYamlELF, Object386)
	TEST (BartleByObjectYamlError, ObjectTypeMisMatch)
	Test that passing two objects with different format types is an error.
	TEST (BartleByObjectYamlELF, SymbolInBSS)
	Test that a symbol in a BSS section is well renamed.
	TEST (BartlebyCAPI, CAPI)
	Test the C API.
	TEST (BartlebyCAPI, CAPI_Invalid_Input)
	Test the C API with invalid inputs.

Detailed Description

Unit tests for Bartleby.

Author

thb-sb

Macro Definition Documentation

ASSERT_SYM_DEFINED

#define ASSERT_SYM_DEFINED	(		_b_,
			_name_
	)		ASSERT_SYM_DEFINEDNESS((_b_), (_name_), true)

Asserts that a symbol is defined.

Parameters

_b_	Bartleby handle.
_name_	Name of the symbol.

ASSERT_SYM_DEFINEDNESS

#define ASSERT_SYM_DEFINEDNESS	(		_b_,
			_name_,
			_exp_
	)

Value:

  do {                                                                         \
    ASSERT_SYM_RESOLVE((_b_), (_name_));                                       \
    ASSERT_EQ(_s_->getValue().isDefined(), (_exp_));                           \
  } while (0)

Asserts the definedness of a symbol.

Parameters

_b_	Bartleby handle.
_name_	Name of the symbol.

ASSERT_SYM_GLOBAL

#define ASSERT_SYM_GLOBAL	(		_b_,
			_name_
	)		ASSERT_SYM_GLOBALNESS((_b_), (_name_), true)

Asserts that a symbol is local.

Parameters

_b_	Bartleby handle.
_name_	Name of the symbol.

ASSERT_SYM_GLOBALNESS

#define ASSERT_SYM_GLOBALNESS	(		_b_,
			_name_,
			_exp_
	)

Value:

  do {                                                                         \
    ASSERT_SYM_RESOLVE((_b_), (_name_));                                       \
    ASSERT_EQ(_s_->getValue().isGlobal(), (_exp_));                            \
  } while (0)

Asserts the globalness of a symbol.

Parameters

_b_	Bartleby handle.
_name_	Name of the symbol.

ASSERT_SYM_LOCAL

#define ASSERT_SYM_LOCAL	(		_b_,
			_name_
	)		ASSERT_SYM_GLOBALNESS((_b_), (_name_), false)

Asserts that a symbol is local.

Parameters

_b_	Bartleby handle.
_name_	Name of the symbol.

ASSERT_SYM_OVERWRITTEN

#define ASSERT_SYM_OVERWRITTEN	(		_b_,
			_name_,
			_exp_
	)

Value:

  do {                                                                         \
    ASSERT_SYM_RESOLVE((_b_), (_name_));                                       \
    ASSERT_TRUE(_s_->getValue().getOverwriteName().has_value() == _exp_);      \
  } while (0)

Asserts the overwrittenness of a symbol.

Parameters

_b_	Bartleby handle.
_name_	Name of the symbol.

ASSERT_SYM_RESOLVE

#define ASSERT_SYM_RESOLVE	(		_b_,
			_name_
	)

Value:

  const auto &_s_ = (_b_).getSymbols().find((_name_));                         \
  ASSERT_NE(_s_, (_b_).getSymbols().end())                                     \
      << "Symbol " << (_name_) << " not found"

Resolves a symbol in the map of symbols.

Parameters

_b_	Bartleby handle.
_name_	Name of the symbol.

Returns

The symbol entry.

ASSERT_SYM_UNDEFINED

#define ASSERT_SYM_UNDEFINED	(		_b_,
			_name_
	)		ASSERT_SYM_DEFINEDNESS((_b_), (_name_), false)

Asserts that a symbol is undefined.

Parameters

_b_	Bartleby handle.
_name_	Name of the symbol.

ASSERT_SYM_WILL_BE_RENAMED

#define ASSERT_SYM_WILL_BE_RENAMED	(		_b_,
			_name_
	)		ASSERT_SYM_OVERWRITTEN((_b_), (_name_), true)

Asserts that a symbol name will be overwritten.

Parameters

_b_	Bartleby handle.
_name_	Name of the symbol.

ASSERT_SYM_WILL_NOT_BE_RENAMED

#define ASSERT_SYM_WILL_NOT_BE_RENAMED	(		_b_,
			_name_
	)		ASSERT_SYM_OVERWRITTEN((_b_), (_name_), false)

Asserts that a symbol name will NOT be overwritten.

Parameters

_b_	Bartleby handle.
_name_	Name of the symbol.

Function Documentation

TEST() [1/5]

TEST	(	BartlebyCAPI	,
		CAPI
	)

Test the C API.

                         {
  llvm::SmallVector<llvm::object::OwningBinary<llvm::object::Binary>, 2>
      Objects;
  ASSERT_TRUE(YAML2Objects("symbols_visibility.yaml",
                           llvm::Triple::ObjectFormatType::ELF, Objects, 2));
 
  auto* bh = ::saq_bartleby_new();
  ASSERT_NE(bh, nullptr);
 
  const auto data = Objects[0].getBinary()->getData();
 
  ASSERT_EQ(::saq_bartleby_add_binary(bh, data.data(), data.size()), 0);
 
  ASSERT_EQ(::saq_bartleby_set_prefix(bh, "prefix_"), 0);
 
  void* out = nullptr;
  size_t out_n = 0;
 
  ASSERT_EQ(::saq_bartleby_build_archive(bh, &out, &out_n), 0);
  ASSERT_TRUE(out_n > 0);
  ASSERT_NE(out, nullptr);
 
  ::free(out);
}

TEST() [2/5]

TEST	(	BartlebyCAPI	,
		CAPI_Invalid_Input
	)

Test the C API with invalid inputs.

                                       {
  auto* bh = ::saq_bartleby_new();
  ASSERT_NE(bh, nullptr);
  char c = 0x42;
 
  ASSERT_EQ(::saq_bartleby_add_binary(nullptr, &c, 1), EINVAL);
  ASSERT_EQ(::saq_bartleby_add_binary(bh, nullptr, 1), EINVAL);
  ASSERT_EQ(::saq_bartleby_add_binary(bh, &c, 0), EINVAL);
  ASSERT_EQ(::saq_bartleby_add_binary(nullptr, nullptr, 0), EINVAL);
 
  void* out = nullptr;
  size_t n = 0;
  ASSERT_EQ(::saq_bartleby_build_archive(nullptr, &out, &n), EINVAL);
  ASSERT_EQ(::saq_bartleby_build_archive(bh, nullptr, nullptr), EINVAL);
  bh = ::saq_bartleby_new();
  ASSERT_EQ(::saq_bartleby_build_archive(bh, &out, nullptr), EINVAL);
  bh = ::saq_bartleby_new();
  ASSERT_EQ(::saq_bartleby_build_archive(bh, nullptr, &n), EINVAL);
}

TEST() [3/5]

TEST	(	BartleByObjectYamlELF	,
		Object386
	)

                                       {
  llvm::SmallVector<llvm::object::OwningBinary<llvm::object::Binary>, 2>
      Objects;
  ASSERT_TRUE(YAML2Objects("symbols_visibility.yaml",
                           llvm::Triple::ObjectFormatType::ELF, Objects, 2));
 
  llvm::DebugFlag = true;
  Bartleby B;
  auto Err = B.addBinary(std::move(Objects[0]));
  ASSERT_FALSE(Err);
 
  ASSERT_SYM_DEFINED(B, "defined_local_symbol");
  ASSERT_SYM_LOCAL(B, "defined_local_symbol");
 
  ASSERT_SYM_DEFINED(B, "defined_global_symbol");
  ASSERT_SYM_GLOBAL(B, "defined_global_symbol");
 
  ASSERT_SYM_UNDEFINED(B, "undefined_symbol");
  ASSERT_SYM_GLOBAL(B, "undefined_symbol");
 
  ASSERT_SYM_UNDEFINED(B, "weak_symbol");
  ASSERT_SYM_LOCAL(B, "weak_symbol");
 
  B.prefixGlobalAndDefinedSymbols("prefix_");
 
  ASSERT_SYM_WILL_NOT_BE_RENAMED(B, "defined_local_symbol");
  ASSERT_SYM_WILL_BE_RENAMED(B, "defined_global_symbol");
  ASSERT_SYM_WILL_NOT_BE_RENAMED(B, "undefined_symbol");
  ASSERT_SYM_WILL_NOT_BE_RENAMED(B, "weak_symbol");
 
  Err = B.addBinary(std::move(Objects[1]));
  ASSERT_FALSE(Err);
 
  ASSERT_SYM_DEFINED(B, "defined_local_symbol");
  ASSERT_SYM_LOCAL(B, "defined_local_symbol");
 
  ASSERT_SYM_DEFINED(B, "defined_global_symbol");
  ASSERT_SYM_GLOBAL(B, "defined_global_symbol");
 
  // Object 2 defined `undefined_symbol`.
  ASSERT_SYM_DEFINED(B, "undefined_symbol");
  ASSERT_SYM_GLOBAL(B, "undefined_symbol");
 
  ASSERT_SYM_UNDEFINED(B, "weak_symbol");
  ASSERT_SYM_LOCAL(B, "weak_symbol");
 
  B.prefixGlobalAndDefinedSymbols("prefix_");
 
  ASSERT_SYM_WILL_NOT_BE_RENAMED(B, "defined_local_symbol");
  ASSERT_SYM_WILL_BE_RENAMED(B, "defined_global_symbol");
  ASSERT_SYM_WILL_BE_RENAMED(B, "undefined_symbol");
  ASSERT_SYM_WILL_NOT_BE_RENAMED(B, "weak_symbol");
 
  auto ArOrErr = Bartleby::buildFinalArchive(std::move(B));
  ASSERT_TRUE(!!ArOrErr);
  auto ArContent = std::move(*ArOrErr);
 
  auto Ar = llvm::object::createBinary(*ArContent);
  ASSERT_TRUE(!!Ar);
 
  auto OwningAr = llvm::object::OwningBinary<llvm::object::Binary>(
      std::move(*Ar), std::move(ArContent));
 
  B = Bartleby();
  ASSERT_FALSE(B.addBinary(std::move(OwningAr)));
 
  ASSERT_SYM_DEFINED(B, "defined_local_symbol");
  ASSERT_SYM_LOCAL(B, "defined_local_symbol");
 
  ASSERT_SYM_DEFINED(B, "prefix_defined_global_symbol");
  ASSERT_SYM_GLOBAL(B, "prefix_defined_global_symbol");
 
  ASSERT_SYM_DEFINED(B, "prefix_undefined_symbol");
  ASSERT_SYM_GLOBAL(B, "prefix_undefined_symbol");
 
  ASSERT_SYM_UNDEFINED(B, "weak_symbol");
  ASSERT_SYM_LOCAL(B, "weak_symbol");
}

TEST() [4/5]

TEST	(	BartleByObjectYamlELF	,
		SymbolInBSS
	)

Test that a symbol in a BSS section is well renamed.

                                         {
  llvm::SmallVector<llvm::object::OwningBinary<llvm::object::Binary>, 1>
      Objects;
  ASSERT_TRUE(YAML2Objects("uninit_symbol_in_BSS.yaml",
                           llvm::Triple::ObjectFormatType::ELF, Objects));
  Bartleby B;
  auto Err = B.addBinary(std::move(Objects[0]));
  ASSERT_FALSE(Err);
 
  ASSERT_SYM_DEFINED(B, "thread_local_var");
  ASSERT_SYM_GLOBAL(B, "thread_local_var");
 
  B.prefixGlobalAndDefinedSymbols("prefix_");
  ASSERT_SYM_WILL_BE_RENAMED(B, "thread_local_var");
}

TEST() [5/5]

TEST	(	BartleByObjectYamlError	,
		ObjectTypeMisMatch
	)

Test that passing two objects with different format types is an error.

                                                  {
  llvm::SmallVector<llvm::object::OwningBinary<llvm::object::Binary>, 2>
      Objects;
  ASSERT_TRUE(YAML2Objects("arm64.yaml", llvm::Triple::ObjectFormatType::MachO,
                           Objects));
 
  ASSERT_TRUE(YAML2Objects("simple_x86_64.yaml",
                           llvm::Triple::ObjectFormatType::ELF, Objects));
 
  Bartleby B;
  ASSERT_FALSE(B.addBinary(std::move(Objects[0])));
  auto Err = B.addBinary(std::move(Objects[1]));
  ASSERT_TRUE(!!Err);
}