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

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

using namespace mcld;
using namespace mcldtest;


// Constructor can do set-up work for all test here.
FactoriesTest::FactoriesTest()
{
	m_pNodeAlloc = new NodeAlloc();
	m_pFileAlloc = new FileAlloc();
}

// Destructor can do clean-up work that doesn't throw exceptions here.
FactoriesTest::~FactoriesTest()
{
	delete m_pNodeAlloc;
	delete m_pFileAlloc;
}

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

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

//==========================================================================//
// Testcases
//
TEST_F( FactoriesTest, node_produce ) {
	NodeAlloc::NodeType* node = m_pNodeAlloc->produce();
	ASSERT_EQ(1, m_pNodeAlloc->size());
	ASSERT_FALSE(m_pNodeAlloc->empty());
	node = m_pNodeAlloc->produce();
	ASSERT_EQ(2, m_pNodeAlloc->size());
	ASSERT_FALSE(m_pNodeAlloc->empty());
	node = m_pNodeAlloc->produce();
	ASSERT_EQ(3, m_pNodeAlloc->size());
	ASSERT_FALSE(m_pNodeAlloc->empty());
}

TEST_F( FactoriesTest, node_iterate ) {
	NodeAlloc::NodeType* node = 0;
	for (int i=0 ; i<100; ++i) {
		node = m_pNodeAlloc->produce();
		node->data = (int*)malloc(sizeof(int));
		*(node->data) = i;
	}

	int counter = 0;
	NodeAlloc::iterator data = m_pNodeAlloc->begin();
	NodeAlloc::iterator dEnd = m_pNodeAlloc->end();
	for (; data!=dEnd; ++data) {
		ASSERT_EQ(counter, *(*data).data );
		free((*data).data);
		(*data).data = 0;
		++counter;
	}
}

TEST_F( FactoriesTest, node_delegate_empty ) {
	NodeAlloc::NodeType* node = 0;
	for (int i=0 ; i<100; ++i) {
		node = m_pNodeAlloc->produce();
		node->data = (int*)malloc(sizeof(int));
		*(node->data) = i;
	}
	NodeAlloc* delegatee = new NodeAlloc();
	m_pNodeAlloc->delegate(*delegatee);
	ASSERT_EQ(100, m_pNodeAlloc->size());
	int counter = 0;
	NodeAlloc::iterator data = m_pNodeAlloc->begin();
	NodeAlloc::iterator dEnd = m_pNodeAlloc->end();
	for (; data!=dEnd; ++data) {
		ASSERT_EQ(counter, *(*data).data );
		free((*data).data);
		(*data).data = 0;
		++counter;
	}
	delete delegatee;
}

TEST_F( FactoriesTest, node_empty_delegate ) {
	NodeAlloc::NodeType* node = 0;
	NodeAlloc* delegatee = new NodeAlloc();
	for (int i=0 ; i<100; ++i) {
		node = delegatee->produce();
		node->data = (int*)malloc(sizeof(int));
		*(node->data) = i;
	}
	m_pNodeAlloc->delegate(*delegatee);
	ASSERT_EQ(100, m_pNodeAlloc->size());
	int counter = 0;
	NodeAlloc::iterator data = m_pNodeAlloc->begin();
	NodeAlloc::iterator dEnd = m_pNodeAlloc->end();
	for (; data!=dEnd; ++data) {
		ASSERT_EQ(counter, *(*data).data );
		free((*data).data);
		(*data).data = 0;
		++counter;
	}
	ASSERT_EQ(0, delegatee->size());
	ASSERT_TRUE(delegatee->empty());
	delete delegatee;
}

TEST_F( FactoriesTest, node_delegate ) {
	NodeAlloc::NodeType* node = 0;
	NodeAlloc* delegatee = new NodeAlloc();
	int counter = 0;
	// produce agent
	for (int i=0 ; i<100; ++i) {
		node = m_pNodeAlloc->produce();
		node->data = (int*)malloc(sizeof(int));
		*(node->data) = counter;
		++counter;
	}

	// produce delegatee
	for (int i=0 ; i<100; ++i) {
		node = delegatee->produce();
		node->data = (int*)malloc(sizeof(int));
		*(node->data) = counter;
		++counter;
	}

	m_pNodeAlloc->delegate(*delegatee);
	ASSERT_EQ(200, m_pNodeAlloc->size());
	ASSERT_FALSE(m_pNodeAlloc->empty());
	NodeAlloc::iterator data = m_pNodeAlloc->begin();
	NodeAlloc::iterator dEnd = m_pNodeAlloc->end();
	for ( counter = 0; data!=dEnd; ++data) {
		ASSERT_EQ(counter, *(*data).data );
		free((*data).data);
		(*data).data = 0;
		++counter;
	}
	ASSERT_EQ(0, delegatee->size());
	ASSERT_TRUE(delegatee->empty());
	delete delegatee;
}

TEST_F( FactoriesTest, node_delegate_self ) {
	NodeAlloc::NodeType* node = 0;
	for (int i=0 ; i<100; ++i) {
		node = m_pNodeAlloc->produce();
		node->data = (int*)malloc(sizeof(int));
		*(node->data) = i;
	}
	ASSERT_EQ(100, m_pNodeAlloc->size());
	m_pNodeAlloc->delegate(*m_pNodeAlloc);
	ASSERT_EQ(100, m_pNodeAlloc->size());
	ASSERT_FALSE(m_pNodeAlloc->empty());
}

TEST_F( FactoriesTest, file_produce ) {
	int counter = 0;
	for (counter=1; counter<1000; ++counter) {
		MCLDFile* file = m_pFileAlloc->produce();
		ASSERT_EQ(counter, m_pFileAlloc->size());
		ASSERT_FALSE(m_pFileAlloc->empty());
	}
}

TEST_F( FactoriesTest, file_produce_by_params ) {
	int counter = 0;
	for (counter=1; counter<1000; ++counter) {
		char name[100];
		sprintf(name, "file %d", counter);
		char path_name[100];
		sprintf(path_name, "/proj/mtk%d", counter);
		MCLDFile* file = m_pFileAlloc->produce( string(name),
							sys::fs::Path(string(path_name)),
							MCLDFile::Archive);
		ASSERT_EQ(counter, m_pFileAlloc->size());
		ASSERT_FALSE(m_pFileAlloc->empty());
		ASSERT_TRUE(file->isRecognized());
		ASSERT_STREQ(name, file->name().data());
	}
}

TEST_F( FactoriesTest, file_iterate ) {
	int counter = 0;
	for (counter=1; counter<1000; ++counter) {
		char name[100];
		sprintf(name, "file %d", counter);
		char path_name[100];
		sprintf(path_name, "/proj/mtk%d", counter);
		MCLDFile* file = m_pFileAlloc->produce( string(name),
							sys::fs::Path(string(path_name)),
							MCLDFile::Archive);
	}

	ASSERT_EQ(counter-1, m_pFileAlloc->size());
	ASSERT_FALSE(m_pFileAlloc->empty());

	MCLDFileFactory::iterator file = m_pFileAlloc->begin();
	MCLDFileFactory::iterator fEnd = m_pFileAlloc->end();

	while (file!=fEnd) {
		ASSERT_TRUE((*file).isRecognized());
		ASSERT_FALSE((*file).name().empty());
		++file;
	}
}