//===- InputTreeTest.cpp --------------------------------------------------===//
//
//                     The MCLinker Project
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "InputTreeTest.h"

#include <vector>
#include <iostream>

#include <mcld/InputTree.h>
#include <mcld/MC/InputFactory.h>
#include <mcld/LinkerConfig.h>
#include <mcld/MC/InputBuilder.h>
#include <mcld/MC/FileAction.h>
#include <mcld/MC/CommandAction.h>

using namespace mcld;
using namespace mcld::test;


// Constructor can do set-up work for all test here.
InputTreeTest::InputTreeTest()
  : m_MemFactory(10), m_ContextFactory(4) {

  // create testee. modify it if need
  m_pConfig = new mcld::LinkerConfig("arm-none-linux-gnueabi");
  m_pAlloc  = new mcld::InputFactory(10, *m_pConfig);
  m_pBuilder = new mcld::InputBuilder(*m_pConfig,
                                      *m_pAlloc,
                                      m_ContextFactory,
                                      m_MemFactory,
                                      false);
  m_pTestee = new mcld::InputTree();
  m_pBuilder->setCurrentTree(*m_pTestee);
}

// Destructor can do clean-up work that doesn't throw exceptions here.
InputTreeTest::~InputTreeTest()
{
  delete m_pTestee;
  delete m_pAlloc;
  delete m_pBuilder;
  delete m_pConfig;
}

// SetUp() will be called immediately before each test.
void InputTreeTest::SetUp()
{
}

// TearDown() will be called immediately after each test.
void InputTreeTest::TearDown()
{
}

//===----------------------------------------------------------------------===//
// Testcases
//
TEST_F( InputTreeTest, Basic_operation ) {

  std::vector<InputAction*> actions;

  size_t position = 0;
  actions.push_back(new StartGroupAction(position++));
  actions.push_back(new InputFileAction(position++, "path1"));
  actions.push_back(new EndGroupAction(position++));

  std::vector<InputAction*>::iterator action;
  for (action = actions.begin(); action != actions.end(); ++action) {
    (*action)->activate(*m_pBuilder);
    delete *action;
  }

  InputTree::iterator node = m_pTestee->root();
  InputTree::const_iterator const_node = node;
  --node;
  --const_node;

  ASSERT_TRUE(isGroup(node));
  ASSERT_TRUE(isGroup(const_node));
  ASSERT_FALSE(m_pAlloc->empty());
  ASSERT_TRUE(1 == m_pAlloc->size());

  --node;

  m_pTestee->enterGroup(node, InputTree::Downward);

  InputTree::const_iterator const_node2 = node;

  ASSERT_FALSE(node.isRoot());

  ASSERT_FALSE(isGroup(node));
  ASSERT_FALSE(isGroup(const_node2));
  ASSERT_FALSE(m_pAlloc->empty());
  ASSERT_FALSE(m_pAlloc->size()==0);

  ASSERT_TRUE(m_pTestee->size()==3);
}

TEST_F( InputTreeTest, forLoop_TEST ) {
  InputTree::iterator node = m_pTestee->root();


  Input* input = m_pAlloc->produce("FileSpec", "path1");
  m_pTestee->insert<InputTree::Inclusive>(node, *input);
  InputTree::const_iterator const_node = node;
  --node;

  for(int i=0 ; i<100 ; ++i)
  {
    Input* input = m_pAlloc->produce("FileSpec", "path1");
    m_pTestee->insert<InputTree::Inclusive>(node, *input);
    ++node;
  }

  m_pTestee->enterGroup(node, InputTree::Downward);
  --node;

  ASSERT_FALSE(node.isRoot());
  ASSERT_TRUE(isGroup(node));
  ASSERT_FALSE(m_pAlloc->empty());
  ASSERT_FALSE(m_pAlloc->size()==100);

  ASSERT_TRUE(m_pTestee->size()==102);
}

TEST_F( InputTreeTest, Nesting_Case ) {
  InputTree::iterator node = m_pTestee->root();

  for(int i=0 ; i<50 ; ++i)
  {
    m_pTestee->enterGroup(node, InputTree::Downward);
    --node;

    Input* input = m_pAlloc->produce("FileSpec", "path1");
    m_pTestee->insert(node, InputTree::Afterward, *input);
    ++node;
  }

  ASSERT_FALSE(node.isRoot());
  ASSERT_FALSE(isGroup(node));
  ASSERT_FALSE(m_pAlloc->empty());
  ASSERT_TRUE(m_pAlloc->size()==50);
  ASSERT_TRUE(m_pTestee->size()==100);
}

TEST_F( InputTreeTest, DFSIterator_BasicTraversal)
{

  InputTree::iterator node = m_pTestee->root();
  Input* input = m_pAlloc->produce("111", "/");
  m_pTestee->insert<InputTree::Inclusive>(node, *input);
  node.move<InputTree::Inclusive>();

  input = m_pAlloc->produce("10", "/");
  m_pTestee->insert<InputTree::Positional>(node, *input);
  m_pTestee->enterGroup<InputTree::Inclusive>(node);
  node.move<InputTree::Inclusive>();

  input = m_pAlloc->produce("7", "/");
  m_pTestee->insert<InputTree::Inclusive>(node, *input);
  input = m_pAlloc->produce("8", "/");
  m_pTestee->insert<InputTree::Positional>(node, *input);

  InputTree::dfs_iterator dfs_it = m_pTestee->dfs_begin();
  InputTree::dfs_iterator dfs_end = m_pTestee->dfs_end();
  ASSERT_STREQ("111", (*dfs_it)->name().c_str());
  ++dfs_it;
  ASSERT_STREQ("7", (**dfs_it).name().c_str());
  ++dfs_it;
  ASSERT_STREQ("8", (**dfs_it).name().c_str());
  ++dfs_it;
  ASSERT_STREQ("10", (**dfs_it).name().c_str());
  ++dfs_it;
  ASSERT_TRUE(dfs_it ==  dfs_end);
}