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