//===- NamePoolTest.cpp ---------------------------------------------------===//
//
// The MCLinker Project
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "NamePoolTest.h"
#include <mcld/LD/NamePool.h>
#include <mcld/LD/Resolver.h>
#include <mcld/LD/StaticResolver.h>
#include <mcld/LD/ResolveInfo.h>
#include <mcld/LD/LDSymbol.h>
#include <llvm/ADT/StringRef.h>
#include <string>
#include <cstdio>
using namespace mcld;
using namespace mcldtest;
// Constructor can do set-up work for all test here.
NamePoolTest::NamePoolTest()
{
// create testee. modify it if need
StaticResolver resolver;
m_pTestee = new NamePool(resolver, 10);
}
// Destructor can do clean-up work that doesn't throw exceptions here.
NamePoolTest::~NamePoolTest()
{
delete m_pTestee;
}
// SetUp() will be called immediately before each test.
void NamePoolTest::SetUp()
{
}
// TearDown() will be called immediately after each test.
void NamePoolTest::TearDown()
{
}
//==========================================================================//
// Testcases
//
TEST_F( NamePoolTest, insertString ) {
const char *s1 = "Hello MCLinker";
llvm::StringRef result1 = m_pTestee->insertString(s1);
EXPECT_NE(s1, result1.data());
EXPECT_STREQ(s1, result1.data());
}
TEST_F( NamePoolTest, insertSameString ) {
const char *s1 = "Hello MCLinker";
std::string s2(s1);
llvm::StringRef result1 = m_pTestee->insertString(s1);
llvm::StringRef result2 = m_pTestee->insertString(s2.c_str());
EXPECT_STREQ(s1, result1.data());
EXPECT_STREQ(s2.c_str(), result2.data());
EXPECT_EQ(result1.data(), result2.data());
}
TEST_F( NamePoolTest, insert_local_defined_Symbol ) {
const char *name = "Hello MCLinker";
bool isDyn = false;
ResolveInfo::Type type = ResolveInfo::Function;
ResolveInfo::Desc desc = ResolveInfo::Define;
ResolveInfo::Binding binding = ResolveInfo::Local;
uint64_t value = 0;
uint64_t size = 0;
ResolveInfo::Visibility other = ResolveInfo::Default;
Resolver::Result result1;
m_pTestee->insertSymbol(name,
isDyn,
type,
desc,
binding,
size,
other,
NULL,
result1);
EXPECT_NE(name, result1.info->name());
EXPECT_STREQ(name, result1.info->name());
EXPECT_EQ(isDyn, result1.info->isDyn());
EXPECT_EQ(type, result1.info->type());
EXPECT_EQ(desc, result1.info->desc());
EXPECT_EQ(binding, result1.info->binding());
EXPECT_EQ(size, result1.info->size());
EXPECT_EQ(other, result1.info->visibility());
Resolver::Result result2;
m_pTestee->insertSymbol(name,
isDyn,
type,
desc,
binding,
size,
other,
NULL,
result2);
EXPECT_NE(name, result1.info->name());
EXPECT_STREQ(name, result1.info->name());
EXPECT_EQ(isDyn, result1.info->isDyn());
EXPECT_EQ(type, result1.info->type());
EXPECT_EQ(desc, result1.info->desc());
EXPECT_EQ(binding, result1.info->binding());
EXPECT_EQ(size, result1.info->size());
EXPECT_EQ(other, result1.info->visibility());
EXPECT_NE(result1.existent, result2.existent);
}
TEST_F( NamePoolTest, insert_global_reference_Symbol ) {
const char *name = "Hello MCLinker";
bool isDyn = false;
ResolveInfo::Type type = ResolveInfo::NoType;
ResolveInfo::Desc desc = ResolveInfo::Undefined;
ResolveInfo::Binding binding = ResolveInfo::Global;
uint64_t size = 0;
ResolveInfo::Visibility other = ResolveInfo::Default;
Resolver::Result result1;
m_pTestee->insertSymbol(name,
isDyn,
type,
desc,
binding,
size,
other,
NULL,
result1);
EXPECT_NE(name, result1.info->name());
EXPECT_STREQ(name, result1.info->name());
EXPECT_EQ(isDyn, result1.info->isDyn());
EXPECT_EQ(type, result1.info->type());
EXPECT_EQ(desc, result1.info->desc());
EXPECT_EQ(binding, result1.info->binding());
EXPECT_EQ(size, result1.info->size());
EXPECT_EQ(other, result1.info->visibility());
Resolver::Result result2;
m_pTestee->insertSymbol(name,
isDyn,
type,
desc,
binding,
size,
other,
NULL,
result2);
EXPECT_EQ(result1.info, result2.info);
Resolver::Result result3;
m_pTestee->insertSymbol("Different Symbol",
isDyn,
type,
desc,
binding,
size,
other,
NULL,
result3);
EXPECT_NE(result1.info, result3.info);
}
TEST_F( NamePoolTest, insertSymbol_after_insert_same_string ) {
const char *name = "Hello MCLinker";
bool isDyn = false;
LDSymbol::Type type = LDSymbol::Defined;
LDSymbol::Binding binding = LDSymbol::Global;
const llvm::MCSectionData *section = 0;
uint64_t value = 0;
uint64_t size = 0;
uint8_t other = 0;
const char *result1 = m_pTestee->insertString(name);
LDSymbol *sym = m_pTestee->insertSymbol(name,
isDyn,
type,
binding,
section,
value,
size,
other);
EXPECT_STREQ(name, sym->name());
EXPECT_EQ(result1, sym->name());
char s[16];
strcpy(s, result1);
const char *result2 = m_pTestee->insertString(result1);
const char *result3 = m_pTestee->insertString(s);
EXPECT_EQ(result1, result2);
EXPECT_EQ(result1, result3);
}
TEST_F( NamePoolTest, insert_16384_weak_reference_symbols ) {
char name[16];
bool isDyn = false;
LDSymbol::Type type = LDSymbol::Reference;
LDSymbol::Binding binding = LDSymbol::Weak;
const llvm::MCSectionData *section = 0;
uint64_t value = 0;
uint64_t size = 0;
uint8_t other = 0;
strcpy(name, "Hello MCLinker");
LDSymbol *syms[128][128];
for(int i=0; i<128 ;++i) {
name[0] = i;
for(int j=0; j<128 ;++j) {
name[1] = j;
syms[i][j] = m_pTestee->insertSymbol(name,
isDyn,
type,
binding,
section,
value,
size,
other);
ASSERT_STREQ(name, syms[i][j]->name());
}
}
for(int i=127; i>=0 ;--i) {
name[0] = i;
for(int j=0; j<128 ;++j) {
name[1] = j;
LDSymbol *sym = m_pTestee->insertSymbol(name,
isDyn,
type,
binding,
section,
value,
size,
other);
ASSERT_EQ(sym, syms[i][j]);
}
}
for(int i=0; i<128 ;++i) {
name[0] = i;
for(int j=0; j<128 ;++j) {
name[1] = j;
LDSymbol *sym = m_pTestee->insertSymbol(name,
isDyn,
type,
binding,
section,
value,
size,
other);
ASSERT_EQ(sym, syms[i][j]);
}
}
}