xref: /frameworks/compile/mclinker/unittests/NamePoolTest.cpp

//===- 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]);
    }
  }
}