Update mclinker for LLVM rebase to r222494.
This corresponds to the following upstream mclinker change:
commit b2f1691276052c4215abf36715d43248d6337cf8
Author: Diana Chen <mysekki@gmail.com>
Date: Tue Nov 25 14:03:29 2014 +0800
option: Allow `-hash-style' can be specified zero or more times
Change-Id: I332546680bb45cf9692adfa2c2d3dcdc84361afc
diff --git a/unittests/BinTreeTest.cpp b/unittests/BinTreeTest.cpp
index e436752..adad138 100644
--- a/unittests/BinTreeTest.cpp
+++ b/unittests/BinTreeTest.cpp
@@ -8,132 +8,121 @@
//===----------------------------------------------------------------------===//
#include "BinTreeTest.h"
-#include <mcld/ADT/TypeTraits.h>
-#include <mcld/InputTree.h>
+#include "mcld/ADT/TypeTraits.h"
+#include "mcld/InputTree.h"
#include <string>
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-BinTreeTest::BinTreeTest()
-{
- // create testee. modify it if need
- m_pTestee = new BinaryTree<int>();
+BinTreeTest::BinTreeTest() {
+ // create testee. modify it if need
+ m_pTestee = new BinaryTree<int>();
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-BinTreeTest::~BinTreeTest()
-{
- delete m_pTestee;
+BinTreeTest::~BinTreeTest() {
+ delete m_pTestee;
}
// SetUp() will be called immediately before each test.
-void BinTreeTest::SetUp()
-{
+void BinTreeTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void BinTreeTest::TearDown()
-{
+void BinTreeTest::TearDown() {
}
//==========================================================================//
// Testcases
//
-
/// General
-TEST_F( BinTreeTest,Two_non_null_tree_merge)
-{
+TEST_F(BinTreeTest, Two_non_null_tree_merge) {
BinaryTree<int>::iterator pos = m_pTestee->root();
- m_pTestee->join<TreeIteratorBase::Rightward>(pos,0);
+ m_pTestee->join<TreeIteratorBase::Rightward>(pos, 0);
--pos;
- m_pTestee->join<TreeIteratorBase::Rightward>(pos,1);
- m_pTestee->join<TreeIteratorBase::Leftward>(pos,1);
+ m_pTestee->join<TreeIteratorBase::Rightward>(pos, 1);
+ m_pTestee->join<TreeIteratorBase::Leftward>(pos, 1);
--pos;
- m_pTestee->join<TreeIteratorBase::Rightward>(pos,2);
- m_pTestee->join<TreeIteratorBase::Leftward>(pos,2);
+ m_pTestee->join<TreeIteratorBase::Rightward>(pos, 2);
+ m_pTestee->join<TreeIteratorBase::Leftward>(pos, 2);
- BinaryTree<int> *mergeTree = new BinaryTree<int>;
+ BinaryTree<int>* mergeTree = new BinaryTree<int>;
BinaryTree<int>::iterator pos2 = mergeTree->root();
- mergeTree->join<TreeIteratorBase::Rightward>(pos2,1);
+ mergeTree->join<TreeIteratorBase::Rightward>(pos2, 1);
--pos2;
- mergeTree->join<TreeIteratorBase::Rightward>(pos2,1);
- mergeTree->join<TreeIteratorBase::Leftward>(pos2,1);
+ mergeTree->join<TreeIteratorBase::Rightward>(pos2, 1);
+ mergeTree->join<TreeIteratorBase::Leftward>(pos2, 1);
- m_pTestee->merge<TreeIteratorBase::Rightward>(pos,*mergeTree);
+ m_pTestee->merge<TreeIteratorBase::Rightward>(pos, *mergeTree);
delete mergeTree;
- EXPECT_TRUE(m_pTestee->size()==8);
+ EXPECT_TRUE(m_pTestee->size() == 8);
}
/// ---- TEST - 2 ----
-TEST_F( BinTreeTest, A_null_tree_merge_a_non_null_tree)
-{
+TEST_F(BinTreeTest, A_null_tree_merge_a_non_null_tree) {
BinaryTree<int>::iterator pos = m_pTestee->root();
- BinaryTree<int> *mergeTree = new BinaryTree<int>;
- mergeTree->join<TreeIteratorBase::Rightward>(pos,0);
+ BinaryTree<int>* mergeTree = new BinaryTree<int>;
+ mergeTree->join<TreeIteratorBase::Rightward>(pos, 0);
--pos;
- mergeTree->join<TreeIteratorBase::Rightward>(pos,1);
- mergeTree->join<TreeIteratorBase::Leftward>(pos,1);
+ mergeTree->join<TreeIteratorBase::Rightward>(pos, 1);
+ mergeTree->join<TreeIteratorBase::Leftward>(pos, 1);
--pos;
- mergeTree->join<TreeIteratorBase::Rightward>(pos,2);
- mergeTree->join<TreeIteratorBase::Leftward>(pos,2);
+ mergeTree->join<TreeIteratorBase::Rightward>(pos, 2);
+ mergeTree->join<TreeIteratorBase::Leftward>(pos, 2);
- m_pTestee->merge<TreeIteratorBase::Rightward>(pos,*mergeTree);
+ m_pTestee->merge<TreeIteratorBase::Rightward>(pos, *mergeTree);
delete mergeTree;
- EXPECT_TRUE(m_pTestee->size()==5);
+ EXPECT_TRUE(m_pTestee->size() == 5);
}
-TEST_F( BinTreeTest, A_non_null_tree_merge_a_null_tree)
-{
+TEST_F(BinTreeTest, A_non_null_tree_merge_a_null_tree) {
BinaryTree<int>::iterator pos = m_pTestee->root();
- m_pTestee->join<TreeIteratorBase::Rightward>(pos,0);
+ m_pTestee->join<TreeIteratorBase::Rightward>(pos, 0);
--pos;
- m_pTestee->join<TreeIteratorBase::Rightward>(pos,1);
- m_pTestee->join<TreeIteratorBase::Leftward>(pos,1);
+ m_pTestee->join<TreeIteratorBase::Rightward>(pos, 1);
+ m_pTestee->join<TreeIteratorBase::Leftward>(pos, 1);
--pos;
- m_pTestee->join<TreeIteratorBase::Rightward>(pos,2);
- m_pTestee->join<TreeIteratorBase::Leftward>(pos,2);
+ m_pTestee->join<TreeIteratorBase::Rightward>(pos, 2);
+ m_pTestee->join<TreeIteratorBase::Leftward>(pos, 2);
- BinaryTree<int> *mergeTree = new BinaryTree<int>;
+ BinaryTree<int>* mergeTree = new BinaryTree<int>;
BinaryTree<int>::iterator pos2 = mergeTree->root();
- mergeTree->merge<TreeIteratorBase::Rightward>(pos2,*m_pTestee);
+ mergeTree->merge<TreeIteratorBase::Rightward>(pos2, *m_pTestee);
- //delete m_pTestee;
- EXPECT_TRUE(mergeTree->size()==5);
+ // delete m_pTestee;
+ EXPECT_TRUE(mergeTree->size() == 5);
delete mergeTree;
}
-TEST_F( BinTreeTest, Two_null_tree_merge)
-{
+TEST_F(BinTreeTest, Two_null_tree_merge) {
BinaryTree<int>::iterator pos = m_pTestee->root();
- BinaryTree<int> *mergeTree = new BinaryTree<int>;
+ BinaryTree<int>* mergeTree = new BinaryTree<int>;
BinaryTree<int>::iterator pos2 = mergeTree->root();
- mergeTree->merge<TreeIteratorBase::Rightward>(pos2,*m_pTestee);
+ mergeTree->merge<TreeIteratorBase::Rightward>(pos2, *m_pTestee);
- //delete m_pTestee;
- EXPECT_TRUE(mergeTree->size()==0);
+ // delete m_pTestee;
+ EXPECT_TRUE(mergeTree->size() == 0);
delete mergeTree;
}
-TEST_F( BinTreeTest, DFSIterator_BasicTraversal)
-{
+TEST_F(BinTreeTest, DFSIterator_BasicTraversal) {
int a = 111, b = 10, c = 9, d = 8, e = 7;
BinaryTree<int>::iterator pos = m_pTestee->root();
- m_pTestee->join<InputTree::Inclusive>(pos,a);
+ m_pTestee->join<InputTree::Inclusive>(pos, a);
pos.move<InputTree::Inclusive>();
- m_pTestee->join<InputTree::Positional>(pos,b);
- m_pTestee->join<InputTree::Inclusive>(pos,c);
+ m_pTestee->join<InputTree::Positional>(pos, b);
+ m_pTestee->join<InputTree::Inclusive>(pos, c);
pos.move<InputTree::Inclusive>();
- m_pTestee->join<InputTree::Positional>(pos,d);
- m_pTestee->join<InputTree::Inclusive>(pos,e);
+ m_pTestee->join<InputTree::Positional>(pos, d);
+ m_pTestee->join<InputTree::Inclusive>(pos, e);
BinaryTree<int>::dfs_iterator dfs_it = m_pTestee->dfs_begin();
BinaryTree<int>::dfs_iterator dfs_end = m_pTestee->dfs_end();
@@ -148,22 +137,21 @@
++dfs_it;
EXPECT_EQ(10, **dfs_it);
++dfs_it;
- EXPECT_TRUE( dfs_it == dfs_end);
+ EXPECT_TRUE(dfs_it == dfs_end);
}
-TEST_F( BinTreeTest, DFSIterator_RightMostTree)
-{
+TEST_F(BinTreeTest, DFSIterator_RightMostTree) {
int a = 0, b = 1, c = 2, d = 3, e = 4;
BinaryTree<int>::iterator pos = m_pTestee->root();
- m_pTestee->join<InputTree::Inclusive>(pos,a);
+ m_pTestee->join<InputTree::Inclusive>(pos, a);
pos.move<InputTree::Inclusive>();
- m_pTestee->join<InputTree::Positional>(pos,b);
+ m_pTestee->join<InputTree::Positional>(pos, b);
pos.move<InputTree::Positional>();
- m_pTestee->join<InputTree::Positional>(pos,c);
+ m_pTestee->join<InputTree::Positional>(pos, c);
pos.move<InputTree::Positional>();
- m_pTestee->join<InputTree::Positional>(pos,d);
+ m_pTestee->join<InputTree::Positional>(pos, d);
pos.move<InputTree::Positional>();
- m_pTestee->join<InputTree::Positional>(pos,e);
+ m_pTestee->join<InputTree::Positional>(pos, e);
BinaryTree<int>::dfs_iterator dfs_it = m_pTestee->dfs_begin();
BinaryTree<int>::dfs_iterator dfs_end = m_pTestee->dfs_end();
@@ -178,36 +166,33 @@
++dfs_it;
ASSERT_EQ(4, **dfs_it);
++dfs_it;
- ASSERT_TRUE( dfs_it == dfs_end);
+ ASSERT_TRUE(dfs_it == dfs_end);
}
-
-TEST_F( BinTreeTest, DFSIterator_SingleNode)
-{
+TEST_F(BinTreeTest, DFSIterator_SingleNode) {
BinaryTree<int>::iterator pos = m_pTestee->root();
- m_pTestee->join<InputTree::Inclusive>(pos,0);
+ m_pTestee->join<InputTree::Inclusive>(pos, 0);
BinaryTree<int>::dfs_iterator dfs_it = m_pTestee->dfs_begin();
BinaryTree<int>::dfs_iterator dfs_end = m_pTestee->dfs_end();
int counter = 0;
- while( dfs_it != dfs_end ) {
+ while (dfs_it != dfs_end) {
++counter;
++dfs_it;
}
ASSERT_EQ(1, counter);
}
-TEST_F( BinTreeTest, BFSIterator_BasicTraversal)
-{
+TEST_F(BinTreeTest, BFSIterator_BasicTraversal) {
int a = 111, b = 10, c = 9, d = 8, e = 7;
BinaryTree<int>::iterator pos = m_pTestee->root();
- m_pTestee->join<InputTree::Inclusive>(pos,a);
+ m_pTestee->join<InputTree::Inclusive>(pos, a);
pos.move<InputTree::Inclusive>();
- m_pTestee->join<InputTree::Positional>(pos,b);
- m_pTestee->join<InputTree::Inclusive>(pos,c);
+ m_pTestee->join<InputTree::Positional>(pos, b);
+ m_pTestee->join<InputTree::Inclusive>(pos, c);
pos.move<InputTree::Inclusive>();
- m_pTestee->join<InputTree::Positional>(pos,d);
- m_pTestee->join<InputTree::Inclusive>(pos,e);
+ m_pTestee->join<InputTree::Positional>(pos, d);
+ m_pTestee->join<InputTree::Inclusive>(pos, e);
BinaryTree<int>::bfs_iterator bfs_it = m_pTestee->bfs_begin();
BinaryTree<int>::bfs_iterator bfs_end = m_pTestee->bfs_end();
@@ -222,24 +207,23 @@
++bfs_it;
ASSERT_EQ(7, **bfs_it);
++bfs_it;
- ASSERT_TRUE(bfs_it == bfs_end);
+ ASSERT_TRUE(bfs_it == bfs_end);
bfs_it = m_pTestee->bfs_begin();
bfs_end = m_pTestee->bfs_end();
}
-TEST_F( BinTreeTest, BFSIterator_RightMostTree)
-{
+TEST_F(BinTreeTest, BFSIterator_RightMostTree) {
int a = 0, b = 1, c = 2, d = 3, e = 4;
BinaryTree<int>::iterator pos = m_pTestee->root();
- m_pTestee->join<InputTree::Inclusive>(pos,a);
+ m_pTestee->join<InputTree::Inclusive>(pos, a);
pos.move<InputTree::Inclusive>();
- m_pTestee->join<InputTree::Positional>(pos,b);
+ m_pTestee->join<InputTree::Positional>(pos, b);
pos.move<InputTree::Positional>();
- m_pTestee->join<InputTree::Positional>(pos,c);
+ m_pTestee->join<InputTree::Positional>(pos, c);
pos.move<InputTree::Positional>();
- m_pTestee->join<InputTree::Positional>(pos,d);
+ m_pTestee->join<InputTree::Positional>(pos, d);
pos.move<InputTree::Positional>();
- m_pTestee->join<InputTree::Positional>(pos,e);
+ m_pTestee->join<InputTree::Positional>(pos, e);
BinaryTree<int>::bfs_iterator bfs_it = m_pTestee->bfs_begin();
BinaryTree<int>::bfs_iterator bfs_end = m_pTestee->bfs_end();
@@ -254,38 +238,35 @@
++bfs_it;
ASSERT_EQ(4, **bfs_it);
++bfs_it;
- ASSERT_TRUE( bfs_it == bfs_end);
+ ASSERT_TRUE(bfs_it == bfs_end);
}
-
-TEST_F( BinTreeTest, BFSIterator_SingleNode)
-{
+TEST_F(BinTreeTest, BFSIterator_SingleNode) {
BinaryTree<int>::iterator pos = m_pTestee->root();
- m_pTestee->join<InputTree::Inclusive>(pos,0);
+ m_pTestee->join<InputTree::Inclusive>(pos, 0);
BinaryTree<int>::bfs_iterator bfs_it = m_pTestee->bfs_begin();
BinaryTree<int>::bfs_iterator bfs_end = m_pTestee->bfs_end();
int counter = 0;
- while( bfs_it != bfs_end ) {
+ while (bfs_it != bfs_end) {
++counter;
++bfs_it;
}
ASSERT_EQ(1, counter);
}
-TEST_F( BinTreeTest, TreeIterator)
-{
+TEST_F(BinTreeTest, TreeIterator) {
int a = 0, b = 1, c = 2, d = 3, e = 4, f = 5;
BinaryTree<int>::iterator pos = m_pTestee->root();
- m_pTestee->join<InputTree::Inclusive>(pos,a);
+ m_pTestee->join<InputTree::Inclusive>(pos, a);
pos.move<InputTree::Inclusive>();
- m_pTestee->join<InputTree::Positional>(pos,b);
+ m_pTestee->join<InputTree::Positional>(pos, b);
pos.move<InputTree::Positional>();
- m_pTestee->join<InputTree::Inclusive>(pos,c);
- m_pTestee->join<InputTree::Positional>(pos,f);
+ m_pTestee->join<InputTree::Inclusive>(pos, c);
+ m_pTestee->join<InputTree::Positional>(pos, f);
pos.move<InputTree::Inclusive>();
- m_pTestee->join<InputTree::Positional>(pos,d);
+ m_pTestee->join<InputTree::Positional>(pos, d);
pos.move<InputTree::Positional>();
- m_pTestee->join<InputTree::Positional>(pos,e);
+ m_pTestee->join<InputTree::Positional>(pos, e);
BinaryTree<int>::iterator it = m_pTestee->begin();
BinaryTree<int>::iterator end = m_pTestee->end();
@@ -309,4 +290,3 @@
++it;
ASSERT_TRUE(it == end);
}
-
diff --git a/unittests/BinTreeTest.h b/unittests/BinTreeTest.h
index 7f4a7f7..0f4b26f 100644
--- a/unittests/BinTreeTest.h
+++ b/unittests/BinTreeTest.h
@@ -13,40 +13,37 @@
#include <gtest.h>
-namespace mcld
-{
+namespace mcld {
class BinTree;
-} // namespace for mcld
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
/** \class BinTreeTest
- * \brief Make sure the interface of BinTree , such as insert , traversal , etc..
+ * \brief Make sure the interface of BinTree , such as insert , traversal ,
+ *etc..
*
* \see BinTree
*/
-class BinTreeTest : public ::testing::Test
-{
-public:
- // Constructor can do set-up work for all test here.
- BinTreeTest();
+class BinTreeTest : public ::testing::Test {
+ public:
+ // Constructor can do set-up work for all test here.
+ BinTreeTest();
- // Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~BinTreeTest();
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~BinTreeTest();
- // SetUp() will be called immediately before each test.
- virtual void SetUp();
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
- // TearDown() will be called immediately after each test.
- virtual void TearDown();
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
-protected:
- mcld::BinaryTree<int>* m_pTestee;
+ protected:
+ mcld::BinaryTree<int>* m_pTestee;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/DirIteratorTest.cpp b/unittests/DirIteratorTest.cpp
index 13472ac..2684466 100644
--- a/unittests/DirIteratorTest.cpp
+++ b/unittests/DirIteratorTest.cpp
@@ -6,7 +6,7 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/Support/Directory.h>
+#include "mcld/Support/Directory.h"
#include "DirIteratorTest.h"
#include <errno.h>
@@ -14,11 +14,9 @@
using namespace mcld::sys::fs;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-DirIteratorTest::DirIteratorTest()
-{
- //FIXME:Some bugs modifies the global value "errno" to non-zero.
+DirIteratorTest::DirIteratorTest() {
+ // FIXME:Some bugs modifies the global value "errno" to non-zero.
// This makes readir() failed when daily build system runs unittest
// Remove this after fixing those bugs
errno = 0;
@@ -28,37 +26,32 @@
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-DirIteratorTest::~DirIteratorTest()
-{
+DirIteratorTest::~DirIteratorTest() {
delete m_pDir;
}
// SetUp() will be called immediately before each test.
-void DirIteratorTest::SetUp()
-{
+void DirIteratorTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void DirIteratorTest::TearDown()
-{
+void DirIteratorTest::TearDown() {
}
//==========================================================================//
// Testcases
//
-TEST_F( DirIteratorTest, open_dir ) {
- ASSERT_TRUE( m_pDir->isGood() );
+TEST_F(DirIteratorTest, open_dir) {
+ ASSERT_TRUE(m_pDir->isGood());
Directory::iterator entry = m_pDir->begin();
Directory::iterator enEnd = m_pDir->end();
size_t size = 0;
- while( entry!=enEnd ) {
+ while (entry != enEnd) {
if (0 != entry.path())
size = entry.path()->native().size();
++entry;
}
}
-
-
diff --git a/unittests/DirIteratorTest.h b/unittests/DirIteratorTest.h
index ea6aaf7..20bf208 100644
--- a/unittests/DirIteratorTest.h
+++ b/unittests/DirIteratorTest.h
@@ -18,35 +18,33 @@
class DirIterator;
}
}
-} // namespace for mcld
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
/** \class DirIteratorTest
* \brief
*
* \see DirIterator
*/
-class DirIteratorTest : public ::testing::Test
-{
-public:
- // Constructor can do set-up work for all test here.
- DirIteratorTest();
+class DirIteratorTest : public ::testing::Test {
+ public:
+ // Constructor can do set-up work for all test here.
+ DirIteratorTest();
- // Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~DirIteratorTest();
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~DirIteratorTest();
- // SetUp() will be called immediately before each test.
- virtual void SetUp();
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
- // TearDown() will be called immediately after each test.
- virtual void TearDown();
-protected:
- mcld::sys::fs::Directory *m_pDir;
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
+
+ protected:
+ mcld::sys::fs::Directory* m_pDir;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/ELFBinaryReaderTest.cpp b/unittests/ELFBinaryReaderTest.cpp
index 7792717..3fe9f3f 100644
--- a/unittests/ELFBinaryReaderTest.cpp
+++ b/unittests/ELFBinaryReaderTest.cpp
@@ -6,49 +6,44 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/LD/ELFBinaryReader.h>
-#include <mcld/Module.h>
-#include <mcld/LinkerScript.h>
-#include <mcld/LinkerConfig.h>
-#include <mcld/IRBuilder.h>
-#include <mcld/GeneralOptions.h>
-#include <mcld/MC/Input.h>
+#include "mcld/LD/ELFBinaryReader.h"
+#include "mcld/Module.h"
+#include "mcld/LinkerScript.h"
+#include "mcld/LinkerConfig.h"
+#include "mcld/IRBuilder.h"
+#include "mcld/GeneralOptions.h"
+#include "mcld/MC/Input.h"
#include "ELFBinaryReaderTest.h"
using namespace mcld;
using namespace mcld::test;
-
// Constructor can do set-up work for all test here.
-ELFBinaryReaderTest::ELFBinaryReaderTest()
-{
+ELFBinaryReaderTest::ELFBinaryReaderTest() {
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-ELFBinaryReaderTest::~ELFBinaryReaderTest()
-{
+ELFBinaryReaderTest::~ELFBinaryReaderTest() {
}
// SetUp() will be called immediately before each test.
-void ELFBinaryReaderTest::SetUp()
-{
+void ELFBinaryReaderTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void ELFBinaryReaderTest::TearDown()
-{
+void ELFBinaryReaderTest::TearDown() {
}
//===----------------------------------------------------------------------===//
// Testcases
//===----------------------------------------------------------------------===//
-TEST_F( ELFBinaryReaderTest, is_myformat) {
+TEST_F(ELFBinaryReaderTest, is_myformat) {
LinkerScript script;
Module module("test", script);
LinkerConfig config;
IRBuilder builder(module, config);
- ELFBinaryReader *reader = new ELFBinaryReader(builder, config);
+ ELFBinaryReader* reader = new ELFBinaryReader(builder, config);
Input input("test.bin");
@@ -61,4 +56,3 @@
delete reader;
}
-
diff --git a/unittests/ELFBinaryReaderTest.h b/unittests/ELFBinaryReaderTest.h
index a9ea042..bc8ee71 100644
--- a/unittests/ELFBinaryReaderTest.h
+++ b/unittests/ELFBinaryReaderTest.h
@@ -16,9 +16,8 @@
namespace test {
-class ELFBinaryReaderTest : public ::testing::Test
-{
-public:
+class ELFBinaryReaderTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
ELFBinaryReaderTest();
@@ -32,8 +31,7 @@
virtual void TearDown();
};
-} // namespace of test
-} // namespace of mcld
+} // namespace of test
+} // namespace of mcld
#endif
-
diff --git a/unittests/ELFReaderTest.cpp b/unittests/ELFReaderTest.cpp
index 1ff2a31..bacddce 100644
--- a/unittests/ELFReaderTest.cpp
+++ b/unittests/ELFReaderTest.cpp
@@ -6,48 +6,46 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <cstdio>
+#include "ELFReaderTest.h"
-#include <llvm/ADT/StringRef.h>
-#include <llvm/Support/ELF.h>
-#include <mcld/IRBuilder.h>
-#include <mcld/TargetOptions.h>
-#include <mcld/LD/ELFReader.h>
-#include <mcld/MC/Input.h>
-#include <mcld/Support/Path.h>
-#include <mcld/Support/MemoryArea.h>
+#include "mcld/IRBuilder.h"
+#include "mcld/TargetOptions.h"
+#include "mcld/LD/ELFReader.h"
+#include "mcld/LD/LDContext.h"
+#include "mcld/MC/Input.h"
+#include "mcld/Support/Path.h"
+#include "mcld/Support/MemoryArea.h"
#include <../lib/Target/X86/X86LDBackend.h>
#include <../lib/Target/X86/X86GNUInfo.h>
-#include "ELFReaderTest.h"
+#include <llvm/ADT/StringRef.h>
+#include <llvm/Support/ELF.h>
+
+#include <cstdio>
using namespace mcld;
using namespace mcld::sys::fs;
using namespace mcldtest;
// Constructor can do set-up work for all test here.
-ELFReaderTest::ELFReaderTest()
- : m_pInput(NULL)
-{
+ELFReaderTest::ELFReaderTest() : m_pInput(NULL) {
m_pConfig = new LinkerConfig("x86_64-linux-gnueabi");
- m_pConfig->targets().setEndian( TargetOptions::Little );
- m_pConfig->targets().setBitClass( 64 );
- Relocation::SetUp( *m_pConfig );
+ m_pConfig->targets().setEndian(TargetOptions::Little);
+ m_pConfig->targets().setBitClass(64);
+ Relocation::SetUp(*m_pConfig);
m_pScript = new LinkerScript();
- m_pInfo = new X86_64GNUInfo( m_pConfig->targets().triple() );
- m_pLDBackend = new X86_64GNULDBackend( *m_pConfig, m_pInfo );
- m_pELFReader = new ELFReader<64, true>( *m_pLDBackend );
+ m_pInfo = new X86_64GNUInfo(m_pConfig->targets().triple());
+ m_pLDBackend = new X86_64GNULDBackend(*m_pConfig, m_pInfo);
+ m_pELFReader = new ELFReader<64, true>(*m_pLDBackend);
m_pModule = new Module(*m_pScript);
- m_pIRBuilder = new IRBuilder( *m_pModule, *m_pConfig);
- m_pELFObjReader = new ELFObjectReader(*m_pLDBackend,
- *m_pIRBuilder,
- *m_pConfig);
+ m_pIRBuilder = new IRBuilder(*m_pModule, *m_pConfig);
+ m_pELFObjReader =
+ new ELFObjectReader(*m_pLDBackend, *m_pIRBuilder, *m_pConfig);
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-ELFReaderTest::~ELFReaderTest()
-{
+ELFReaderTest::~ELFReaderTest() {
delete m_pConfig;
delete m_pLDBackend;
delete m_pELFReader;
@@ -58,57 +56,54 @@
}
// SetUp() will be called immediately before each test.
-void ELFReaderTest::SetUp()
-{
+void ELFReaderTest::SetUp() {
Path path(TOPDIR);
path.append("unittests/test_x86_64.o");
m_pInput = m_pIRBuilder->ReadInput("test_x86_64", path);
- ASSERT_TRUE(NULL!=m_pInput);
+ ASSERT_TRUE(NULL != m_pInput);
ASSERT_TRUE(m_pInput->hasMemArea());
size_t hdr_size = m_pELFReader->getELFHeaderSize();
- llvm::StringRef region = m_pInput->memArea()->request(m_pInput->fileOffset(),
- hdr_size);
+ llvm::StringRef region =
+ m_pInput->memArea()->request(m_pInput->fileOffset(), hdr_size);
const char* ELF_hdr = region.begin();
bool shdr_result = m_pELFReader->readSectionHeaders(*m_pInput, ELF_hdr);
ASSERT_TRUE(shdr_result);
}
// TearDown() will be called immediately after each test.
-void ELFReaderTest::TearDown()
-{
+void ELFReaderTest::TearDown() {
}
//===----------------------------------------------------------------------===//
// Testcases
//===----------------------------------------------------------------------===//
-TEST_F( ELFReaderTest, read_section_headers ) {
+TEST_F(ELFReaderTest, read_section_headers) {
ASSERT_EQ(m_pInput->context()->numOfSections(), 13);
LDContext::const_sect_iterator iter = m_pInput->context()->sectBegin();
- ++iter; /// test section[1]
+ ++iter; /// test section[1]
ASSERT_EQ(".text", (*iter)->name());
ASSERT_EQ(llvm::ELF::SHT_PROGBITS, (*iter)->type());
ASSERT_EQ(0x40, (*iter)->offset());
ASSERT_EQ(0x15, (*iter)->size());
- ASSERT_TRUE(llvm::ELF::SHF_ALLOC & (*iter)->flag()); //AX
+ ASSERT_TRUE(llvm::ELF::SHF_ALLOC & (*iter)->flag()); // AX
ASSERT_EQ(0x4, (*iter)->align());
ASSERT_EQ(NULL, (*iter)->getLink());
ASSERT_EQ(0, (*iter)->getInfo());
}
-TEST_F( ELFReaderTest, read_symbol_and_rela )
-{
+TEST_F(ELFReaderTest, read_symbol_and_rela) {
ASSERT_TRUE(m_pInput->hasMemArea());
ASSERT_TRUE(m_pInput->hasContext());
m_pInput->setType(Input::Object);
// -- read symbols
LDSection* symtab_shdr = m_pInput->context()->getSection(".symtab");
- ASSERT_TRUE(NULL!=symtab_shdr);
+ ASSERT_TRUE(NULL != symtab_shdr);
LDSection* strtab_shdr = symtab_shdr->getLink();
- ASSERT_TRUE(NULL!=strtab_shdr);
+ ASSERT_TRUE(NULL != strtab_shdr);
llvm::StringRef symtab_region = m_pInput->memArea()->request(
m_pInput->fileOffset() + symtab_shdr->offset(), symtab_shdr->size());
@@ -116,46 +111,44 @@
llvm::StringRef strtab_region = m_pInput->memArea()->request(
m_pInput->fileOffset() + strtab_shdr->offset(), strtab_shdr->size());
const char* strtab = strtab_region.begin();
- bool result = m_pELFReader->readSymbols(*m_pInput, *m_pIRBuilder,
- symtab_region, strtab);
+ bool result = m_pELFReader->readSymbols(
+ *m_pInput, *m_pIRBuilder, symtab_region, strtab);
ASSERT_TRUE(result);
ASSERT_EQ("hello.c", std::string(m_pInput->context()->getSymbol(1)->name()));
ASSERT_EQ("puts", std::string(m_pInput->context()->getSymbol(10)->name()));
- ASSERT_TRUE(NULL==m_pInput->context()->getSymbol(11));
+ ASSERT_TRUE(NULL == m_pInput->context()->getSymbol(11));
// -- read relocations
MemoryArea* mem = m_pInput->memArea();
LDContext::sect_iterator rs = m_pInput->context()->relocSectBegin();
- ASSERT_TRUE(rs!=m_pInput->context()->relocSectEnd());
+ ASSERT_TRUE(rs != m_pInput->context()->relocSectEnd());
ASSERT_EQ(".rela.text", (*rs)->name());
uint64_t offset = m_pInput->fileOffset() + (*rs)->offset();
uint64_t size = (*rs)->size();
llvm::StringRef region = mem->request(offset, size);
- IRBuilder::CreateRelocData(**rs); /// create relocation data for the header
+ IRBuilder::CreateRelocData(**rs); /// create relocation data for the header
ASSERT_EQ(llvm::ELF::SHT_RELA, (*rs)->type());
ASSERT_TRUE(m_pELFReader->readRela(*m_pInput, **rs, region));
- const RelocData::RelocationListType &rRelocs =
- (*rs)->getRelocData()->getRelocationList();
+ const RelocData::RelocationListType& rRelocs =
+ (*rs)->getRelocData()->getRelocationList();
RelocData::const_iterator rReloc = rRelocs.begin();
ASSERT_EQ(2, rRelocs.size());
- ASSERT_TRUE(rRelocs.end()!=rReloc);
- ++rReloc; /// test rRelocs[1]
+ ASSERT_TRUE(rRelocs.end() != rReloc);
+ ++rReloc; /// test rRelocs[1]
ASSERT_EQ("puts", std::string(rReloc->symInfo()->name()));
ASSERT_EQ(llvm::ELF::R_X86_64_PC32, rReloc->type());
ASSERT_EQ(0x0, rReloc->symValue());
ASSERT_EQ(-0x4, rReloc->addend());
}
-TEST_F( ELFReaderTest, read_regular_sections ) {
- ASSERT_TRUE( m_pELFObjReader->readSections(*m_pInput) );
+TEST_F(ELFReaderTest, read_regular_sections) {
+ ASSERT_TRUE(m_pELFObjReader->readSections(*m_pInput));
}
-TEST_F( ELFReaderTest, is_my_format ) {
+TEST_F(ELFReaderTest, is_my_format) {
bool doContinue;
- ASSERT_TRUE( m_pELFObjReader->isMyFormat(*m_pInput, doContinue) );
+ ASSERT_TRUE(m_pELFObjReader->isMyFormat(*m_pInput, doContinue));
}
-
-
diff --git a/unittests/ELFReaderTest.h b/unittests/ELFReaderTest.h
index abe99b1..b36eede 100644
--- a/unittests/ELFReaderTest.h
+++ b/unittests/ELFReaderTest.h
@@ -10,24 +10,23 @@
#define MCLD_ELFREADER_TEST_H
#include <gtest.h>
-#include <mcld/LinkerConfig.h>
-#include <mcld/LinkerScript.h>
-#include <mcld/LD/ELFReaderIf.h>
-#include <mcld/LD/ELFReader.h>
-#include <mcld/LD/ELFObjectReader.h>
-#include <mcld/Target/GNULDBackend.h>
-#include <mcld/MC/InputBuilder.h>
+#include "mcld/LinkerConfig.h"
+#include "mcld/LinkerScript.h"
+#include "mcld/LD/ELFReaderIf.h"
+#include "mcld/LD/ELFReader.h"
+#include "mcld/LD/ELFObjectReader.h"
+#include "mcld/Target/GNULDBackend.h"
+#include "mcld/MC/InputBuilder.h"
namespace mcld {
- template<> class ELFReader<64, true>;
-} // namespace for mcld
+template <>
+class ELFReader<64, true>;
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
-class ELFReaderTest : public ::testing::Test
-{
-public:
+class ELFReaderTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
ELFReaderTest();
@@ -40,7 +39,7 @@
// TearDown() will be called immediately after each test.
virtual void TearDown();
-protected:
+ protected:
mcld::Input* m_pInput;
mcld::LinkerConfig* m_pConfig;
mcld::LinkerScript* m_pScript;
@@ -52,7 +51,6 @@
mcld::ELFObjectReader* m_pELFObjReader;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/FactoriesTest.cpp b/unittests/FactoriesTest.cpp
index 9301fb9..fdc7109 100644
--- a/unittests/FactoriesTest.cpp
+++ b/unittests/FactoriesTest.cpp
@@ -13,208 +13,200 @@
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();
+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;
+FactoriesTest::~FactoriesTest() {
+ delete m_pNodeAlloc;
+ delete m_pFileAlloc;
}
// SetUp() will be called immediately before each test.
-void FactoriesTest::SetUp()
-{
+void FactoriesTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void FactoriesTest::TearDown()
-{
+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_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;
- }
+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;
- }
+ 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_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_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;
- }
+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;
- }
+ // 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;
+ 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, 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) {
+ 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_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);
- }
+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());
+ ASSERT_EQ(counter - 1, m_pFileAlloc->size());
+ ASSERT_FALSE(m_pFileAlloc->empty());
- MCLDFileFactory::iterator file = m_pFileAlloc->begin();
- MCLDFileFactory::iterator fEnd = m_pFileAlloc->end();
+ 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;
- }
+ while (file != fEnd) {
+ ASSERT_TRUE((*file).isRecognized());
+ ASSERT_FALSE((*file).name().empty());
+ ++file;
+ }
}
-
diff --git a/unittests/FactoriesTest.h b/unittests/FactoriesTest.h
index 484b801..e89732e 100644
--- a/unittests/FactoriesTest.h
+++ b/unittests/FactoriesTest.h
@@ -12,38 +12,36 @@
#include "mcld/ADT/TreeAllocator.h"
#include "mcld/MC/MCLDFile.h"
-namespace mcldtest
-{
+namespace mcldtest {
/** \class FactoriesTest
* \brief Test cases for factories - NodeFactory and MCLDFileFactory.
*
* \see Factories
*/
-class FactoriesTest : public ::testing::Test
-{
-public:
- // Constructor can do set-up work for all test here.
- FactoriesTest();
+class FactoriesTest : public ::testing::Test {
+ public:
+ // Constructor can do set-up work for all test here.
+ FactoriesTest();
- // Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~FactoriesTest();
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~FactoriesTest();
- // SetUp() will be called immediately before each test.
- virtual void SetUp();
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
- // TearDown() will be called immediately after each test.
- virtual void TearDown();
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
-protected:
- typedef mcld::NodeFactory<int> NodeAlloc;
- typedef mcld::MCLDFileFactory FileAlloc;
-protected:
- NodeAlloc* m_pNodeAlloc;
- FileAlloc *m_pFileAlloc;
+ protected:
+ typedef mcld::NodeFactory<int> NodeAlloc;
+ typedef mcld::MCLDFileFactory FileAlloc;
+
+ protected:
+ NodeAlloc* m_pNodeAlloc;
+ FileAlloc* m_pFileAlloc;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/FileHandleTest.cpp b/unittests/FileHandleTest.cpp
index dc9ecdd..e810430 100644
--- a/unittests/FileHandleTest.cpp
+++ b/unittests/FileHandleTest.cpp
@@ -6,8 +6,8 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/Support/FileHandle.h>
-#include <mcld/Support/Path.h>
+#include "mcld/Support/FileHandle.h"
+#include "mcld/Support/Path.h"
#include <fcntl.h>
#include <errno.h>
#include "FileHandleTest.h"
@@ -15,28 +15,23 @@
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-FileHandleTest::FileHandleTest()
-{
+FileHandleTest::FileHandleTest() {
// create testee. modify it if need
m_pTestee = new FileHandle();
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-FileHandleTest::~FileHandleTest()
-{
+FileHandleTest::~FileHandleTest() {
delete m_pTestee;
}
// SetUp() will be called immediately before each test.
-void FileHandleTest::SetUp()
-{
+void FileHandleTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void FileHandleTest::TearDown()
-{
+void FileHandleTest::TearDown() {
}
//===----------------------------------------------------------------------===//
@@ -45,7 +40,8 @@
TEST_F(FileHandleTest, open_close) {
mcld::sys::fs::Path path(TOPDIR);
path.append("unittests/test.txt");
- ASSERT_TRUE(m_pTestee->open(path, FileHandle::ReadOnly));
+ ASSERT_TRUE(m_pTestee->open(path, FileHandle::OpenMode(FileHandle::ReadOnly),
+ FileHandle::Permission(FileHandle::System)));
ASSERT_TRUE(m_pTestee->isOpened());
ASSERT_TRUE(m_pTestee->isGood());
ASSERT_TRUE(m_pTestee->isOwned());
@@ -86,7 +82,8 @@
TEST_F(FileHandleTest, fail_close) {
mcld::sys::fs::Path path(TOPDIR);
path.append("unittests/test.txt");
- ASSERT_TRUE(m_pTestee->open(path, FileHandle::ReadOnly));
+ ASSERT_TRUE(m_pTestee->open(path, FileHandle::OpenMode(FileHandle::ReadOnly),
+ FileHandle::Permission(FileHandle::System)));
ASSERT_TRUE(m_pTestee->isOpened());
ASSERT_TRUE(m_pTestee->isGood());
diff --git a/unittests/FileHandleTest.h b/unittests/FileHandleTest.h
index 45d4ab1..650c97d 100644
--- a/unittests/FileHandleTest.h
+++ b/unittests/FileHandleTest.h
@@ -11,23 +11,20 @@
#include <gtest.h>
-namespace mcld
-{
+namespace mcld {
class FileHandle;
-} // namespace for mcld
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
/** \class FileHandleTest
* \brief
*
* \see FileHandle
*/
-class FileHandleTest : public ::testing::Test
-{
-public:
+class FileHandleTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
FileHandleTest();
@@ -40,11 +37,10 @@
// TearDown() will be called immediately after each test.
virtual void TearDown();
-protected:
+ protected:
mcld::FileHandle* m_pTestee;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/FragmentRefTest.cpp b/unittests/FragmentRefTest.cpp
index 881cdb8..a067542 100644
--- a/unittests/FragmentRefTest.cpp
+++ b/unittests/FragmentRefTest.cpp
@@ -8,12 +8,12 @@
//===----------------------------------------------------------------------===//
#include "FragmentRefTest.h"
-#include <mcld/Fragment/FragmentRef.h>
-#include <mcld/Fragment/RegionFragment.h>
-#include <mcld/Support/MemoryAreaFactory.h>
-#include <mcld/Support/FileHandle.h>
-#include <mcld/Support/MemoryRegion.h>
-#include <mcld/Support/Path.h>
+#include "mcld/Fragment/FragmentRef.h"
+#include "mcld/Fragment/RegionFragment.h"
+#include "mcld/Support/MemoryAreaFactory.h"
+#include "mcld/Support/FileHandle.h"
+#include "mcld/Support/MemoryRegion.h"
+#include "mcld/Support/Path.h"
#include <llvm/ADT/StringRef.h>
using namespace mcld;
@@ -21,50 +21,49 @@
using namespace mcldtest;
// Constructor can do set-up work for all test here.
-FragmentRefTest::FragmentRefTest()
-{
+FragmentRefTest::FragmentRefTest() {
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-FragmentRefTest::~FragmentRefTest()
-{
+FragmentRefTest::~FragmentRefTest() {
}
// SetUp() will be called immediately before each test.
-void FragmentRefTest::SetUp()
-{
+void FragmentRefTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void FragmentRefTest::TearDown()
-{
+void FragmentRefTest::TearDown() {
}
-//==========================================================================//
+//============================================================================//
// Testcases
//
-TEST_F( FragmentRefTest, ) {
+TEST_F(FragmentRefTest, ) {
Path path(TOPDIR);
path.append("unittests/test3.txt");
MemoryAreaFactory* areaFactory = new MemoryAreaFactory(1);
- MemoryArea* area = areaFactory->produce(path, FileHandle::ReadWrite);
+ MemoryArea* area =
+ areaFactory->produce(path, FileHandle::OpenMode(FileHandle::ReadWrite),
+ FileHandle::Permission(FileHandle::System));
llvm::StringRef region = area->request(0, 4096);
- RegionFragment *frag = new RegionFragment(region);
- FragmentRef *ref = FragmentRef::Create(*frag, 0x0);
+ RegionFragment* frag = new RegionFragment(region);
+ FragmentRef* ref = FragmentRef::Create(*frag, 0x0);
ASSERT_EQ('H', region.data()[0]);
ASSERT_TRUE(4096 == region.size());
ASSERT_EQ('H', frag->getRegion().data()[0]);
ASSERT_TRUE(4096 == frag->getRegion().size());
ASSERT_EQ(frag, ref->frag());
- ASSERT_EQ('H', static_cast<RegionFragment*>(ref->frag())->getRegion().data()[0]);
- ASSERT_TRUE(4096 == static_cast<RegionFragment*>(ref->frag())->getRegion().size());
- //ASSERT_EQ('H', ref->deref()[0]);
+ ASSERT_EQ('H',
+ static_cast<RegionFragment*>(ref->frag())->getRegion().data()[0]);
+ ASSERT_TRUE(4096 ==
+ static_cast<RegionFragment*>(ref->frag())->getRegion().size());
+ // ASSERT_EQ('H', ref->deref()[0]);
ASSERT_TRUE(RegionFragment::classof(frag));
delete frag;
delete areaFactory;
}
-
diff --git a/unittests/FragmentRefTest.h b/unittests/FragmentRefTest.h
index 17de587..c5e8d91 100644
--- a/unittests/FragmentRefTest.h
+++ b/unittests/FragmentRefTest.h
@@ -12,23 +12,20 @@
#include <gtest.h>
-namespace mcld
-{
+namespace mcld {
class FragmentRef;
-} // namespace for mcld
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
/** \class FragmentRefTest
* \brief Reference Test
*
* \see FragmentRef
*/
-class FragmentRefTest : public ::testing::Test
-{
-public:
+class FragmentRefTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
FragmentRefTest();
@@ -42,7 +39,6 @@
virtual void TearDown();
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/FragmentTest.cpp b/unittests/FragmentTest.cpp
index 273c98d..ae93015 100644
--- a/unittests/FragmentTest.cpp
+++ b/unittests/FragmentTest.cpp
@@ -1,4 +1,4 @@
-//===- FragmentTest.cpp -------------------------------------------------------===//
+//===- FragmentTest.cpp ---------------------------------------------------===//
//
// The MCLinker Project
//
@@ -8,38 +8,33 @@
//===----------------------------------------------------------------------===//
#include "FragmentTest.h"
-#include <mcld/Fragment/Fragment.h>
-#include <mcld/LD/SectionData.h>
-#include <mcld/LD/LDSection.h>
+#include "mcld/Fragment/Fragment.h"
+#include "mcld/LD/SectionData.h"
+#include "mcld/LD/LDSection.h"
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-FragmentTest::FragmentTest()
-{
+FragmentTest::FragmentTest() {
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-FragmentTest::~FragmentTest()
-{
+FragmentTest::~FragmentTest() {
}
// SetUp() will be called immediately before each test.
-void FragmentTest::SetUp()
-{
+void FragmentTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void FragmentTest::TearDown()
-{
+void FragmentTest::TearDown() {
}
//===----------------------------------------------------------------------===//
// Testcases
-TEST_F( FragmentTest, Fragment_constructor ) {
+TEST_F(FragmentTest, Fragment_constructor) {
LDSection* test = LDSection::Create("test", LDFileFormat::Null, 0, 0);
SectionData* s = SectionData::Create(*test);
new Fragment(Fragment::Alignment, s);
@@ -51,10 +46,10 @@
EXPECT_TRUE(5 == s->size());
LDSection::Destroy(test);
-// SectionData::Destroy(s);
+ // SectionData::Destroy(s);
}
-TEST_F( FragmentTest, Fragment_trivial_function ) {
+TEST_F(FragmentTest, Fragment_trivial_function) {
LDSection* test = LDSection::Create("test", LDFileFormat::Null, 0, 0);
SectionData* s = SectionData::Create(*test);
Fragment* f = new Fragment(Fragment::Alignment, s);
@@ -64,11 +59,9 @@
f->setOffset(5566);
EXPECT_TRUE(5566 == f->getOffset());
- //always return true
- EXPECT_TRUE(f->classof(new Fragment(Fragment::Region, s)) );
+ // always return true
+ EXPECT_TRUE(f->classof(new Fragment(Fragment::Region, s)));
LDSection::Destroy(test);
-// SectionData::Destroy(s);
+ // SectionData::Destroy(s);
}
-
-
diff --git a/unittests/FragmentTest.h b/unittests/FragmentTest.h
index 8c1489c..938cd9a 100644
--- a/unittests/FragmentTest.h
+++ b/unittests/FragmentTest.h
@@ -11,23 +11,20 @@
#include <gtest.h>
-namespace mcld
-{
+namespace mcld {
class Fragment;
-} // namespace for mcld
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
/** \class FragmentTest
* \brief Unit test for mcld::Fragment.
*
* \see Fragment
*/
-class FragmentTest : public ::testing::Test
-{
-public:
+class FragmentTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
FragmentTest();
@@ -40,11 +37,10 @@
// TearDown() will be called immediately after each test.
virtual void TearDown();
-protected:
+ protected:
mcld::Fragment* m_pTestee;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/GCFactoryListTraitsTest.cpp b/unittests/GCFactoryListTraitsTest.cpp
index db8842c..7fecb26 100644
--- a/unittests/GCFactoryListTraitsTest.cpp
+++ b/unittests/GCFactoryListTraitsTest.cpp
@@ -12,8 +12,7 @@
using namespace mcldtest;
// Constructor can do set-up work for all test here.
-GCFactoryListTraitsTest::GCFactoryListTraitsTest()
-{
+GCFactoryListTraitsTest::GCFactoryListTraitsTest() {
// Allocate the nodes.
m_pNodesAlloc = new Node* [10];
#define ALLOCATE_NODE(i) m_pNodesAlloc[(i)] = m_NodeFactory.produce(i);
@@ -31,13 +30,11 @@
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-GCFactoryListTraitsTest::~GCFactoryListTraitsTest()
-{
+GCFactoryListTraitsTest::~GCFactoryListTraitsTest() {
}
// SetUp() will be called immediately before each test.
-void GCFactoryListTraitsTest::SetUp()
-{
+void GCFactoryListTraitsTest::SetUp() {
// Reset the node value and (re)insert into the iplist.
for (unsigned i = 0; i < 10; i++) {
m_pNodesAlloc[i]->setValue(m_pNodesAlloc[i]->getInitialValue());
@@ -46,8 +43,7 @@
}
// TearDown() will be called immediately after each test.
-void GCFactoryListTraitsTest::TearDown()
-{
+void GCFactoryListTraitsTest::TearDown() {
// Erasing of llvm::iplist won't destroy the allocation of the nodes managed
// by the GCFactory (i.e., NodeFactory.)
m_pNodeList.clear();
@@ -57,62 +53,66 @@
// Testcases
//
-#define CHECK_NODE_VALUE(v_) do { \
- ASSERT_TRUE(v_ == it->getValue()); \
- it++; \
-} while (false)
+#define CHECK_NODE_VALUE(v_) \
+ do { \
+ ASSERT_TRUE(v_ == it->getValue()); \
+ it++; \
+ } while (false)
-#define CHECK_LIST_VALUE(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) do { \
- llvm::iplist<Node>::const_iterator it = m_pNodeList.begin(); \
- CHECK_NODE_VALUE(v1); \
- CHECK_NODE_VALUE(v2); \
- CHECK_NODE_VALUE(v3); \
- CHECK_NODE_VALUE(v4); \
- CHECK_NODE_VALUE(v5); \
- CHECK_NODE_VALUE(v6); \
- CHECK_NODE_VALUE(v7); \
- CHECK_NODE_VALUE(v8); \
- CHECK_NODE_VALUE(v9); \
- CHECK_NODE_VALUE(v10); \
-} while (false)
+#define CHECK_LIST_VALUE(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+ do { \
+ llvm::iplist<Node>::const_iterator it = m_pNodeList.begin(); \
+ CHECK_NODE_VALUE(v1); \
+ CHECK_NODE_VALUE(v2); \
+ CHECK_NODE_VALUE(v3); \
+ CHECK_NODE_VALUE(v4); \
+ CHECK_NODE_VALUE(v5); \
+ CHECK_NODE_VALUE(v6); \
+ CHECK_NODE_VALUE(v7); \
+ CHECK_NODE_VALUE(v8); \
+ CHECK_NODE_VALUE(v9); \
+ CHECK_NODE_VALUE(v10); \
+ } while (false)
-TEST_F( GCFactoryListTraitsTest, Basic) {
+TEST_F(GCFactoryListTraitsTest, Basic) {
ASSERT_TRUE(10 == m_pNodeList.size());
CHECK_LIST_VALUE(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
}
-TEST_F( GCFactoryListTraitsTest, BasicAgain) {
+TEST_F(GCFactoryListTraitsTest, BasicAgain) {
ASSERT_TRUE(10 == m_pNodeList.size());
CHECK_LIST_VALUE(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
}
-TEST_F( GCFactoryListTraitsTest, Clear) {
+TEST_F(GCFactoryListTraitsTest, Clear) {
m_pNodeList.clear();
ASSERT_TRUE(0 == m_pNodeList.size());
}
-TEST_F( GCFactoryListTraitsTest, PushThenPop) {
- Node *NewNode = m_NodeFactory.produce(11);
+TEST_F(GCFactoryListTraitsTest, PushThenPop) {
+ Node* NewNode = m_NodeFactory.produce(11);
m_pNodeList.push_back(NewNode);
ASSERT_TRUE(11 == m_pNodeList.size());
m_pNodeList.pop_back();
ASSERT_TRUE(10 == m_pNodeList.size());
}
-TEST_F( GCFactoryListTraitsTest, CodeIterator) {
+TEST_F(GCFactoryListTraitsTest, CodeIterator) {
// to test whether there's compilation error for const template
for (llvm::iplist<Node>::const_iterator I = m_pNodeList.begin(),
- E = m_pNodeList.end(); I != E; I++)
+ E = m_pNodeList.end();
+ I != E;
+ I++)
I->getValue();
}
-TEST_F( GCFactoryListTraitsTest, Empty) {
+TEST_F(GCFactoryListTraitsTest, Empty) {
ASSERT_FALSE(m_pNodeList.empty());
m_pNodeList.clear();
ASSERT_TRUE(m_pNodeList.empty());
}
-TEST_F( GCFactoryListTraitsTest, EraseAndSize) {
+TEST_F(GCFactoryListTraitsTest, EraseAndSize) {
ASSERT_FALSE(m_pNodeList.empty());
m_pNodeList.erase(m_pNodeList.begin());
m_pNodeList.erase(m_pNodeList.begin());
diff --git a/unittests/GCFactoryListTraitsTest.h b/unittests/GCFactoryListTraitsTest.h
index a551848..9326b5b 100644
--- a/unittests/GCFactoryListTraitsTest.h
+++ b/unittests/GCFactoryListTraitsTest.h
@@ -11,89 +11,85 @@
#include <gtest.h>
-#include <mcld/Support/GCFactoryListTraits.h>
+#include "mcld/Support/GCFactoryListTraits.h"
#include <llvm/ADT/ilist_node.h>
-#include <mcld/Support/GCFactory.h>
+#include "mcld/Support/GCFactory.h"
-namespace mcldtest
-{
+namespace mcldtest {
/** \class GCFactoryListTraitsTest
* \brief
*
* \see GCFactoryListTraits
*/
-class GCFactoryListTraitsTest : public ::testing::Test
-{
-public:
+class GCFactoryListTraitsTest : public ::testing::Test {
+ public:
/** \class GCFactoryListTraitsTest
* \brief Node used in the test
*
*/
class NodeFactory;
- class Node : public llvm::ilist_node<Node>
- {
+ class Node : public llvm::ilist_node<Node> {
friend class NodeFactory;
- private:
+
+ private:
unsigned m_Init;
unsigned m_Value;
- public:
- Node() : m_Init(0), m_Value(0) { }
+ public:
+ Node() : m_Init(0), m_Value(0) {}
- Node(unsigned pInit) : m_Init(pInit), m_Value(pInit) { }
+ Node(unsigned pInit) : m_Init(pInit), m_Value(pInit) {}
- unsigned getInitialValue() const {
- return m_Init;
- }
+ unsigned getInitialValue() const { return m_Init; }
- inline unsigned getValue() const
- { return m_Value; }
+ inline unsigned getValue() const { return m_Value; }
- inline void setValue(unsigned pValue)
- { m_Value = pValue; }
+ inline void setValue(unsigned pValue) { m_Value = pValue; }
};
class NodeFactory : public mcld::GCFactory<Node, 0> {
- public:
- NodeFactory() : mcld::GCFactory<Node, 0>(16) { }
+ public:
+ NodeFactory() : mcld::GCFactory<Node, 0>(16) {}
- Node *produce(unsigned pInit) {
- Node *result = allocate();
+ Node* produce(unsigned pInit) {
+ Node* result = allocate();
new (result) Node(pInit);
return result;
}
};
- // Constructor can do set-up work for all test here.
- GCFactoryListTraitsTest();
+ // Constructor can do set-up work for all test here.
+ GCFactoryListTraitsTest();
- // Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~GCFactoryListTraitsTest();
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~GCFactoryListTraitsTest();
- // SetUp() will be called immediately before each test.
- virtual void SetUp();
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
- // TearDown() will be called immediately after each test.
- virtual void TearDown();
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
- const llvm::iplist<Node, mcld::GCFactoryListTraits<Node> > &getNodeList() const
- { return m_pNodeList; }
+ const llvm::iplist<Node, mcld::GCFactoryListTraits<Node> >& getNodeList()
+ const {
+ return m_pNodeList;
+ }
- llvm::iplist<Node, mcld::GCFactoryListTraits<Node> > &getNodeList()
- { return m_pNodeList; }
+ llvm::iplist<Node, mcld::GCFactoryListTraits<Node> >& getNodeList() {
+ return m_pNodeList;
+ }
-protected:
+ protected:
NodeFactory m_NodeFactory;
- Node **m_pNodesAlloc;
+ Node** m_pNodesAlloc;
llvm::iplist<Node, mcld::GCFactoryListTraits<Node> > m_pNodeList;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/GraphTest.cpp b/unittests/GraphTest.cpp
index 0c97567..bd25707 100644
--- a/unittests/GraphTest.cpp
+++ b/unittests/GraphTest.cpp
@@ -7,38 +7,33 @@
//
//===----------------------------------------------------------------------===//
#include "GraphTest.h"
-#include <mcld/ADT/GraphLite/Digraph.h>
-#include <mcld/ADT/GraphLite/ListDigraph.h>
+#include "mcld/ADT/GraphLite/Digraph.h"
+#include "mcld/ADT/GraphLite/ListDigraph.h"
using namespace mcld;
using namespace mcld::test;
using namespace mcld::graph;
// Constructor can do set-up work for all test here.
-GraphTest::GraphTest()
-{
+GraphTest::GraphTest() {
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-GraphTest::~GraphTest()
-{
+GraphTest::~GraphTest() {
}
// SetUp() will be called immediately before each test.
-void GraphTest::SetUp()
-{
+void GraphTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void GraphTest::TearDown()
-{
+void GraphTest::TearDown() {
}
//===----------------------------------------------------------------------===//
// Testcases
//===----------------------------------------------------------------------===//
-TEST_F(GraphTest, list_digraph_add_n_erase_nodes_1)
-{
+TEST_F(GraphTest, list_digraph_add_n_erase_nodes_1) {
ListDigraph graph;
ListDigraph::Node* u1 = graph.addNode();
@@ -47,17 +42,17 @@
ASSERT_TRUE(NULL == u1->first_in);
ASSERT_TRUE(NULL == u1->first_out);
- ASSERT_TRUE(u2 == u1->prev);
+ ASSERT_TRUE(u2 == u1->prev);
ASSERT_TRUE(NULL == u1->next);
ASSERT_TRUE(NULL == u2->first_in);
ASSERT_TRUE(NULL == u2->first_out);
- ASSERT_TRUE(u3 == u2->prev);
- ASSERT_TRUE(u1 == u2->next);
+ ASSERT_TRUE(u3 == u2->prev);
+ ASSERT_TRUE(u1 == u2->next);
ASSERT_TRUE(NULL == u3->first_in);
ASSERT_TRUE(NULL == u3->first_out);
- ASSERT_TRUE(u2 == u3->next);
+ ASSERT_TRUE(u2 == u3->next);
ASSERT_TRUE(NULL == u3->prev);
ListDigraph::Node* head = NULL;
@@ -68,12 +63,12 @@
ASSERT_TRUE(NULL == u1->first_in);
ASSERT_TRUE(NULL == u1->first_out);
- ASSERT_TRUE(u3 == u1->prev);
+ ASSERT_TRUE(u3 == u1->prev);
ASSERT_TRUE(NULL == u1->next);
ASSERT_TRUE(NULL == u3->first_in);
ASSERT_TRUE(NULL == u3->first_out);
- ASSERT_TRUE(u1 == u3->next);
+ ASSERT_TRUE(u1 == u3->next);
ASSERT_TRUE(NULL == u3->prev);
ASSERT_TRUE(NULL == u2->first_in);
@@ -85,8 +80,7 @@
ASSERT_TRUE(head == u3);
}
-TEST_F(GraphTest, list_digraph_add_n_erase_nodes_2)
-{
+TEST_F(GraphTest, list_digraph_add_n_erase_nodes_2) {
ListDigraph graph;
ListDigraph::Node* u1 = graph.addNode();
@@ -95,17 +89,17 @@
ASSERT_TRUE(NULL == u1->first_in);
ASSERT_TRUE(NULL == u1->first_out);
- ASSERT_TRUE(u2 == u1->prev);
+ ASSERT_TRUE(u2 == u1->prev);
ASSERT_TRUE(NULL == u1->next);
ASSERT_TRUE(NULL == u2->first_in);
ASSERT_TRUE(NULL == u2->first_out);
- ASSERT_TRUE(u3 == u2->prev);
- ASSERT_TRUE(u1 == u2->next);
+ ASSERT_TRUE(u3 == u2->prev);
+ ASSERT_TRUE(u1 == u2->next);
ASSERT_TRUE(NULL == u3->first_in);
ASSERT_TRUE(NULL == u3->first_out);
- ASSERT_TRUE(u2 == u3->next);
+ ASSERT_TRUE(u2 == u3->next);
ASSERT_TRUE(NULL == u3->prev);
ListDigraph::Node* head = NULL;
@@ -121,20 +115,19 @@
ASSERT_TRUE(NULL == u2->first_in);
ASSERT_TRUE(NULL == u2->first_out);
- ASSERT_TRUE(u3 == u2->prev);
+ ASSERT_TRUE(u3 == u2->prev);
ASSERT_TRUE(NULL == u2->next);
ASSERT_TRUE(NULL == u3->first_in);
ASSERT_TRUE(NULL == u3->first_out);
- ASSERT_TRUE(u2 == u3->next);
+ ASSERT_TRUE(u2 == u3->next);
ASSERT_TRUE(NULL == u3->prev);
graph.getHead(head);
ASSERT_TRUE(head == u3);
}
-TEST_F(GraphTest, list_digraph_add_n_erase_nodes_3)
-{
+TEST_F(GraphTest, list_digraph_add_n_erase_nodes_3) {
ListDigraph graph;
ListDigraph::Node* u1 = graph.addNode();
@@ -143,17 +136,17 @@
ASSERT_TRUE(NULL == u1->first_in);
ASSERT_TRUE(NULL == u1->first_out);
- ASSERT_TRUE(u2 == u1->prev);
+ ASSERT_TRUE(u2 == u1->prev);
ASSERT_TRUE(NULL == u1->next);
ASSERT_TRUE(NULL == u2->first_in);
ASSERT_TRUE(NULL == u2->first_out);
- ASSERT_TRUE(u3 == u2->prev);
- ASSERT_TRUE(u1 == u2->next);
+ ASSERT_TRUE(u3 == u2->prev);
+ ASSERT_TRUE(u1 == u2->next);
ASSERT_TRUE(NULL == u3->first_in);
ASSERT_TRUE(NULL == u3->first_out);
- ASSERT_TRUE(u2 == u3->next);
+ ASSERT_TRUE(u2 == u3->next);
ASSERT_TRUE(NULL == u3->prev);
ListDigraph::Node* head = NULL;
@@ -169,21 +162,19 @@
ASSERT_TRUE(NULL == u1->first_in);
ASSERT_TRUE(NULL == u1->first_out);
- ASSERT_TRUE(u2 == u1->prev);
+ ASSERT_TRUE(u2 == u1->prev);
ASSERT_TRUE(NULL == u1->next);
ASSERT_TRUE(NULL == u2->first_in);
ASSERT_TRUE(NULL == u2->first_out);
- ASSERT_TRUE(u1 == u2->next);
+ ASSERT_TRUE(u1 == u2->next);
ASSERT_TRUE(NULL == u2->prev);
graph.getHead(head);
ASSERT_TRUE(head == u2);
-
}
-TEST_F(GraphTest, list_digraph_add_arcs_1)
-{
+TEST_F(GraphTest, list_digraph_add_arcs_1) {
ListDigraph graph;
ListDigraph::Node* u1 = graph.addNode();
@@ -203,8 +194,7 @@
ASSERT_TRUE(u3->first_in == a2 && u3->first_out == a3);
}
-TEST_F(GraphTest, list_digraph_add_arcs_2)
-{
+TEST_F(GraphTest, list_digraph_add_arcs_2) {
ListDigraph graph;
ListDigraph::Node* u1 = graph.addNode();
@@ -224,8 +214,7 @@
ASSERT_TRUE(u3->first_in == a3 && u3->first_out == NULL);
}
-TEST_F(GraphTest, list_digraph_add_n_erase_arcs_1)
-{
+TEST_F(GraphTest, list_digraph_add_n_erase_arcs_1) {
ListDigraph graph;
ListDigraph::Node* u1 = graph.addNode();
@@ -251,9 +240,7 @@
ASSERT_TRUE(NULL == a2->next_in);
}
-
-TEST_F(GraphTest, list_digraph_add_n_erase_arcs_2)
-{
+TEST_F(GraphTest, list_digraph_add_n_erase_arcs_2) {
ListDigraph graph;
ListDigraph::Node* u1 = graph.addNode();
@@ -279,8 +266,7 @@
ASSERT_TRUE(NULL == a1->next_in);
}
-TEST_F(GraphTest, list_digraph_add_n_erase_arcs_3)
-{
+TEST_F(GraphTest, list_digraph_add_n_erase_arcs_3) {
ListDigraph graph;
ListDigraph::Node* u1 = graph.addNode();
@@ -306,8 +292,7 @@
ASSERT_TRUE(NULL == a3->next_in);
}
-TEST_F(GraphTest, list_digraph_add_n_erase_arcs_4)
-{
+TEST_F(GraphTest, list_digraph_add_n_erase_arcs_4) {
ListDigraph graph;
ListDigraph::Node* u1 = graph.addNode();
@@ -323,11 +308,9 @@
ASSERT_TRUE(u2->first_in == NULL);
ASSERT_TRUE(u3->first_in == NULL);
ASSERT_TRUE(a1->next_in == NULL);
-
}
-TEST_F(GraphTest, api_test)
-{
+TEST_F(GraphTest, api_test) {
Digraph graph;
Digraph::Node node = graph.addNode();
diff --git a/unittests/GraphTest.h b/unittests/GraphTest.h
index a71276b..0e18b74 100644
--- a/unittests/GraphTest.h
+++ b/unittests/GraphTest.h
@@ -11,13 +11,11 @@
#include <gtest.h>
-
namespace mcld {
namespace test {
-class GraphTest : public ::testing::Test
-{
-public:
+class GraphTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
GraphTest();
@@ -31,8 +29,7 @@
virtual void TearDown();
};
-} // namespace of test
-} // namespace of mcld
+} // namespace of test
+} // namespace of mcld
#endif
-
diff --git a/unittests/HashTableTest.cpp b/unittests/HashTableTest.cpp
index fe67e95..595b1e1 100644
--- a/unittests/HashTableTest.cpp
+++ b/unittests/HashTableTest.cpp
@@ -8,78 +8,63 @@
//===----------------------------------------------------------------------===//
#include "HashTableTest.h"
-#include <mcld/ADT/HashEntry.h>
-#include <mcld/ADT/HashTable.h>
+#include "mcld/ADT/HashEntry.h"
+#include "mcld/ADT/HashTable.h"
#include <cstdlib>
using namespace std;
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-HashTableTest::HashTableTest()
-{
+HashTableTest::HashTableTest() {
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-HashTableTest::~HashTableTest()
-{
+HashTableTest::~HashTableTest() {
}
// SetUp() will be called immediately before each test.
-void HashTableTest::SetUp()
-{
+void HashTableTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void HashTableTest::TearDown()
-{
+void HashTableTest::TearDown() {
}
//==========================================================================//
// Testcases
//
-struct IntCompare
-{
- bool operator()(int X, int Y) const
- { return (X==Y); }
+struct IntCompare {
+ bool operator()(int X, int Y) const { return (X == Y); }
};
-struct PtrCompare
-{
- bool operator()(const int* X, const int* Y) const
- { return (X==Y); }
+struct PtrCompare {
+ bool operator()(const int* X, const int* Y) const { return (X == Y); }
};
-struct PtrHash
-{
- size_t operator()(const int* pKey) const
- {
- return (unsigned((uintptr_t)pKey) >> 4) ^
- (unsigned((uintptr_t)pKey) >> 9);
+struct PtrHash {
+ size_t operator()(const int* pKey) const {
+ return (unsigned((uintptr_t)pKey) >> 4) ^ (unsigned((uintptr_t)pKey) >> 9);
}
};
-struct IntHash
-{
- size_t operator()(int pKey) const
- { return pKey; }
+struct IntHash {
+ size_t operator()(int pKey) const { return pKey; }
};
-struct IntMod3Hash
-{
- size_t operator()(int pKey) const
- { return pKey % 3; }
+struct IntMod3Hash {
+ size_t operator()(int pKey) const { return pKey % 3; }
};
-TEST_F( HashTableTest, ptr_entry ) {
+TEST_F(HashTableTest, ptr_entry) {
int A = 1;
int* pA = &A;
typedef HashEntry<int*, int, PtrCompare> HashEntryType;
- typedef HashTable<HashEntryType, PtrHash, EntryFactory<HashEntryType> > HashTableTy;
- HashTableTy *hashTable = new HashTableTy(0);
+ typedef HashTable<HashEntryType, PtrHash, EntryFactory<HashEntryType> >
+ HashTableTy;
+ HashTableTy* hashTable = new HashTableTy(0);
bool exist;
HashTableTy::entry_type* entry = 0;
@@ -90,11 +75,11 @@
HashTableTy::iterator iter;
iter = hashTable->find(NULL);
- EXPECT_TRUE(iter==hashTable->end());
+ EXPECT_TRUE(iter == hashTable->end());
delete hashTable;
}
-TEST_F( HashTableTest, constructor ) {
+TEST_F(HashTableTest, constructor) {
typedef HashEntry<int, int, IntCompare> HashEntryType;
HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> > hashTable(16);
EXPECT_TRUE(17 == hashTable.numOfBuckets());
@@ -102,10 +87,11 @@
EXPECT_TRUE(0 == hashTable.numOfEntries());
}
-TEST_F( HashTableTest, allocattion ) {
+TEST_F(HashTableTest, allocattion) {
typedef HashEntry<int, int, IntCompare> HashEntryType;
- typedef HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> > HashTableTy;
- HashTableTy *hashTable = new HashTableTy(22);
+ typedef HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> >
+ HashTableTy;
+ HashTableTy* hashTable = new HashTableTy(22);
bool exist;
int key = 100;
@@ -119,20 +105,21 @@
delete hashTable;
}
-TEST_F( HashTableTest, alloc100 ) {
+TEST_F(HashTableTest, alloc100) {
typedef HashEntry<int, int, IntCompare> HashEntryType;
- typedef HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> > HashTableTy;
- HashTableTy *hashTable = new HashTableTy(22);
+ typedef HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> >
+ HashTableTy;
+ HashTableTy* hashTable = new HashTableTy(22);
bool exist;
HashTableTy::entry_type* entry = 0;
- for (int key=0; key<100; ++key) {
+ for (int key = 0; key < 100; ++key) {
entry = hashTable->insert(key, exist);
EXPECT_FALSE(hashTable->empty());
EXPECT_FALSE(exist);
EXPECT_FALSE(NULL == entry);
EXPECT_TRUE(key == entry->key());
- entry->setValue(key+10);
+ entry->setValue(key + 10);
}
EXPECT_FALSE(hashTable->empty());
@@ -141,21 +128,22 @@
delete hashTable;
}
-TEST_F( HashTableTest, erase100 ) {
+TEST_F(HashTableTest, erase100) {
typedef HashEntry<int, int, IntCompare> HashEntryType;
- typedef HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> > HashTableTy;
- HashTableTy *hashTable = new HashTableTy(0);
+ typedef HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> >
+ HashTableTy;
+ HashTableTy* hashTable = new HashTableTy(0);
bool exist;
HashTableTy::entry_type* entry = 0;
- for (unsigned int key=0; key<100; ++key)
+ for (unsigned int key = 0; key < 100; ++key)
entry = hashTable->insert(key, exist);
EXPECT_FALSE(hashTable->empty());
int count;
HashTableTy::iterator iter;
- for (unsigned int key=0; key<100; ++key) {
+ for (unsigned int key = 0; key < 100; ++key) {
count = hashTable->erase(key);
EXPECT_EQ(1, count);
iter = hashTable->find(key);
@@ -166,21 +154,22 @@
delete hashTable;
}
-TEST_F( HashTableTest, clear) {
+TEST_F(HashTableTest, clear) {
typedef HashEntry<int, int, IntCompare> HashEntryType;
- typedef HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> > HashTableTy;
- HashTableTy *hashTable = new HashTableTy(22);
+ typedef HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> >
+ HashTableTy;
+ HashTableTy* hashTable = new HashTableTy(22);
bool exist;
HashTableTy::entry_type* entry = 0;
- for (unsigned int key=0; key<100; ++key) {
+ for (unsigned int key = 0; key < 100; ++key) {
entry = hashTable->insert(key, exist);
}
hashTable->clear();
HashTableTy::iterator iter;
- for (unsigned int key=0; key<100; ++key) {
+ for (unsigned int key = 0; key < 100; ++key) {
iter = hashTable->find(key);
EXPECT_TRUE(iter == hashTable->end());
}
@@ -189,21 +178,22 @@
delete hashTable;
}
-TEST_F( HashTableTest, tombstone ) {
+TEST_F(HashTableTest, tombstone) {
typedef HashEntry<int, int, IntCompare> HashEntryType;
- typedef HashTable<HashEntryType, IntMod3Hash, EntryFactory<HashEntryType> > HashTableTy;
- HashTableTy *hashTable = new HashTableTy();
+ typedef HashTable<HashEntryType, IntMod3Hash, EntryFactory<HashEntryType> >
+ HashTableTy;
+ HashTableTy* hashTable = new HashTableTy();
bool exist;
HashTableTy::entry_type* entry = 0;
- for (unsigned int key=0; key<100; ++key) {
+ for (unsigned int key = 0; key < 100; ++key) {
entry = hashTable->insert(key, exist);
}
EXPECT_FALSE(hashTable->empty());
int count;
HashTableTy::iterator iter;
- for (unsigned int key=0; key<20; ++key) {
+ for (unsigned int key = 0; key < 20; ++key) {
count = hashTable->erase(key);
EXPECT_EQ(1, count);
iter = hashTable->find(key);
@@ -211,12 +201,12 @@
}
EXPECT_TRUE(80 == hashTable->numOfEntries());
- for (unsigned int key=20; key<100; ++key) {
+ for (unsigned int key = 20; key < 100; ++key) {
iter = hashTable->find(key);
EXPECT_TRUE(iter != hashTable->end());
}
- for (unsigned int key=0; key<20; ++key) {
+ for (unsigned int key = 0; key < 20; ++key) {
entry = hashTable->insert(key, exist);
}
EXPECT_TRUE(100 == hashTable->numOfEntries());
@@ -225,66 +215,68 @@
delete hashTable;
}
-TEST_F( HashTableTest, rehash_test ) {
+TEST_F(HashTableTest, rehash_test) {
typedef HashEntry<int, int, IntCompare> HashEntryType;
- typedef HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> > HashTableTy;
- HashTableTy *hashTable = new HashTableTy(0);
+ typedef HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> >
+ HashTableTy;
+ HashTableTy* hashTable = new HashTableTy(0);
bool exist;
HashTableTy::entry_type* entry = 0;
- for (unsigned int key=0; key<400000; ++key) {
+ for (unsigned int key = 0; key < 400000; ++key) {
entry = hashTable->insert(key, exist);
- entry->setValue(key+10);
+ entry->setValue(key + 10);
}
HashTableTy::iterator iter;
- for (int key=0; key<400000; ++key) {
+ for (int key = 0; key < 400000; ++key) {
iter = hashTable->find(key);
- EXPECT_EQ((key+10), iter.getEntry()->value());
+ EXPECT_EQ((key + 10), iter.getEntry()->value());
}
delete hashTable;
}
-TEST_F( HashTableTest, bucket_iterator ) {
+TEST_F(HashTableTest, bucket_iterator) {
typedef HashEntry<int, int, IntCompare> HashEntryType;
- typedef HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> > HashTableTy;
- HashTableTy *hashTable = new HashTableTy(0);
+ typedef HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> >
+ HashTableTy;
+ HashTableTy* hashTable = new HashTableTy(0);
bool exist;
HashTableTy::entry_type* entry = 0;
- for (unsigned int key=0; key<400000; ++key) {
+ for (unsigned int key = 0; key < 400000; ++key) {
entry = hashTable->insert(key, exist);
- entry->setValue(key+10);
+ entry->setValue(key + 10);
}
HashTableTy::iterator iter, iEnd = hashTable->end();
int counter = 0;
for (iter = hashTable->begin(); iter != iEnd; ++iter) {
- EXPECT_EQ(iter.getEntry()->key()+10, iter.getEntry()->value());
+ EXPECT_EQ(iter.getEntry()->key() + 10, iter.getEntry()->value());
++counter;
}
EXPECT_EQ(400000, counter);
delete hashTable;
}
-
-TEST_F( HashTableTest, chain_iterator_single ) {
+TEST_F(HashTableTest, chain_iterator_single) {
typedef HashEntry<int, int, IntCompare> HashEntryType;
- typedef HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> > HashTableTy;
- HashTableTy *hashTable = new HashTableTy();
+ typedef HashTable<HashEntryType, IntHash, EntryFactory<HashEntryType> >
+ HashTableTy;
+ HashTableTy* hashTable = new HashTableTy();
bool exist;
HashTableTy::entry_type* entry = 0;
- for (int key=0; key<16; ++key) {
- entry = hashTable->insert(key*37, exist);
- entry->setValue(key+10);
+ for (int key = 0; key < 16; ++key) {
+ entry = hashTable->insert(key * 37, exist);
+ entry->setValue(key + 10);
}
- for (int key=0; key<16; ++key) {
+ for (int key = 0; key < 16; ++key) {
int counter = 0;
- HashTableTy::chain_iterator iter, iEnd = hashTable->end(key*37);
- for (iter = hashTable->begin(key*37); iter != iEnd; ++iter) {
- EXPECT_EQ(key+10, iter.getEntry()->value());
+ HashTableTy::chain_iterator iter, iEnd = hashTable->end(key * 37);
+ for (iter = hashTable->begin(key * 37); iter != iEnd; ++iter) {
+ EXPECT_EQ(key + 10, iter.getEntry()->value());
++counter;
}
EXPECT_EQ(1, counter);
@@ -292,22 +284,19 @@
delete hashTable;
}
-struct FixHash
-{
- size_t operator()(int pKey) const {
- return 10;
- }
+struct FixHash {
+ size_t operator()(int pKey) const { return 10; }
};
-
-TEST_F( HashTableTest, chain_iterator_list ) {
+TEST_F(HashTableTest, chain_iterator_list) {
typedef HashEntry<int, int, IntCompare> HashEntryType;
- typedef HashTable<HashEntryType, FixHash, EntryFactory<HashEntryType> > HashTableTy;
- HashTableTy *hashTable = new HashTableTy();
+ typedef HashTable<HashEntryType, FixHash, EntryFactory<HashEntryType> >
+ HashTableTy;
+ HashTableTy* hashTable = new HashTableTy();
bool exist;
HashTableTy::entry_type* entry = 0;
- for (unsigned int key=0; key<16; ++key) {
+ for (unsigned int key = 0; key < 16; ++key) {
entry = hashTable->insert(key, exist);
ASSERT_FALSE(exist);
entry->setValue(key);
diff --git a/unittests/HashTableTest.h b/unittests/HashTableTest.h
index c07c991..dd4739a 100644
--- a/unittests/HashTableTest.h
+++ b/unittests/HashTableTest.h
@@ -12,31 +12,28 @@
#include <gtest.h>
-namespace mcldtest
-{
+namespace mcldtest {
/** \class HashTableTest
* \brief Testcase for HashTable
*
* \see HashTable
*/
-class HashTableTest : public ::testing::Test
-{
-public:
- // Constructor can do set-up work for all test here.
- HashTableTest();
+class HashTableTest : public ::testing::Test {
+ public:
+ // Constructor can do set-up work for all test here.
+ HashTableTest();
- // Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~HashTableTest();
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~HashTableTest();
- // SetUp() will be called immediately before each test.
- virtual void SetUp();
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
- // TearDown() will be called immediately after each test.
- virtual void TearDown();
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/InputTreeTest.cpp b/unittests/InputTreeTest.cpp
index 6af81d8..d8951b9 100644
--- a/unittests/InputTreeTest.cpp
+++ b/unittests/InputTreeTest.cpp
@@ -11,36 +11,29 @@
#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>
+#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) {
-
+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_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()
-{
+InputTreeTest::~InputTreeTest() {
delete m_pTestee;
delete m_pAlloc;
delete m_pBuilder;
@@ -48,20 +41,17 @@
}
// SetUp() will be called immediately before each test.
-void InputTreeTest::SetUp()
-{
+void InputTreeTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void InputTreeTest::TearDown()
-{
+void InputTreeTest::TearDown() {
}
//===----------------------------------------------------------------------===//
// Testcases
//
-TEST_F( InputTreeTest, Basic_operation ) {
-
+TEST_F(InputTreeTest, Basic_operation) {
std::vector<InputAction*> actions;
size_t position = 0;
@@ -96,22 +86,20 @@
ASSERT_FALSE(isGroup(node));
ASSERT_FALSE(isGroup(const_node2));
ASSERT_FALSE(m_pAlloc->empty());
- ASSERT_FALSE(m_pAlloc->size()==0);
+ ASSERT_FALSE(m_pAlloc->size() == 0);
- ASSERT_TRUE(m_pTestee->size()==3);
+ ASSERT_TRUE(m_pTestee->size() == 3);
}
-TEST_F( InputTreeTest, forLoop_TEST ) {
+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)
- {
+ for (int i = 0; i < 100; ++i) {
Input* input = m_pAlloc->produce("FileSpec", "path1");
m_pTestee->insert<InputTree::Inclusive>(node, *input);
++node;
@@ -123,16 +111,15 @@
ASSERT_FALSE(node.isRoot());
ASSERT_TRUE(isGroup(node));
ASSERT_FALSE(m_pAlloc->empty());
- ASSERT_FALSE(m_pAlloc->size()==100);
+ ASSERT_FALSE(m_pAlloc->size() == 100);
- ASSERT_TRUE(m_pTestee->size()==102);
+ ASSERT_TRUE(m_pTestee->size() == 102);
}
-TEST_F( InputTreeTest, Nesting_Case ) {
+TEST_F(InputTreeTest, Nesting_Case) {
InputTree::iterator node = m_pTestee->root();
- for(int i=0 ; i<50 ; ++i)
- {
+ for (int i = 0; i < 50; ++i) {
m_pTestee->enterGroup(node, InputTree::Downward);
--node;
@@ -144,13 +131,11 @@
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);
+ ASSERT_TRUE(m_pAlloc->size() == 50);
+ ASSERT_TRUE(m_pTestee->size() == 100);
}
-TEST_F( InputTreeTest, DFSIterator_BasicTraversal)
-{
-
+TEST_F(InputTreeTest, DFSIterator_BasicTraversal) {
InputTree::iterator node = m_pTestee->root();
Input* input = m_pAlloc->produce("111", "/");
m_pTestee->insert<InputTree::Inclusive>(node, *input);
@@ -176,6 +161,5 @@
++dfs_it;
ASSERT_STREQ("10", (**dfs_it).name().c_str());
++dfs_it;
- ASSERT_TRUE(dfs_it == dfs_end);
+ ASSERT_TRUE(dfs_it == dfs_end);
}
-
diff --git a/unittests/InputTreeTest.h b/unittests/InputTreeTest.h
index 31be6fd..dc522d8 100644
--- a/unittests/InputTreeTest.h
+++ b/unittests/InputTreeTest.h
@@ -10,8 +10,8 @@
#define UNITTESTS_INPUTTREE_TEST_H
#include <gtest.h>
-#include <mcld/MC/ContextFactory.h>
-#include <mcld/Support/MemoryAreaFactory.h>
+#include "mcld/MC/ContextFactory.h"
+#include "mcld/Support/MemoryAreaFactory.h"
namespace mcld {
@@ -27,9 +27,8 @@
*
* \see InputTree
*/
-class InputTreeTest : public ::testing::Test
-{
-public:
+class InputTreeTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
InputTreeTest();
@@ -42,7 +41,7 @@
// TearDown() will be called immediately after each test.
virtual void TearDown();
-protected:
+ protected:
mcld::LinkerConfig* m_pConfig;
mcld::InputFactory* m_pAlloc;
@@ -53,8 +52,7 @@
mcld::InputTree* m_pTestee;
};
-} // namespace of test
-} // namespace of mcld
+} // namespace of test
+} // namespace of mcld
#endif
-
diff --git a/unittests/LDSymbolTest.cpp b/unittests/LDSymbolTest.cpp
index e0e681d..e2479e7 100644
--- a/unittests/LDSymbolTest.cpp
+++ b/unittests/LDSymbolTest.cpp
@@ -7,36 +7,30 @@
//
//===----------------------------------------------------------------------===//
-#include <mcld/LD/LDSymbol.h>
+#include "mcld/LD/LDSymbol.h"
#include "LDSymbolTest.h"
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-LDSymbolTest::LDSymbolTest()
-{
+LDSymbolTest::LDSymbolTest() {
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-LDSymbolTest::~LDSymbolTest()
-{
+LDSymbolTest::~LDSymbolTest() {
}
// SetUp() will be called immediately before each test.
-void LDSymbolTest::SetUp()
-{
+void LDSymbolTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void LDSymbolTest::TearDown()
-{
+void LDSymbolTest::TearDown() {
}
//==========================================================================//
// Testcases
//
-TEST_F( LDSymbolTest, produce ) {
+TEST_F(LDSymbolTest, produce) {
}
-
diff --git a/unittests/LDSymbolTest.h b/unittests/LDSymbolTest.h
index 43d6b8a..42d7fb0 100644
--- a/unittests/LDSymbolTest.h
+++ b/unittests/LDSymbolTest.h
@@ -12,20 +12,17 @@
#include <gtest.h>
-namespace mcld
-{
+namespace mcld {
class LDSymbol;
-} // namespace for mcld
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
/** \class LDSymbolTest
*/
-class LDSymbolTest : public ::testing::Test
-{
-public:
+class LDSymbolTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
LDSymbolTest();
@@ -37,10 +34,8 @@
// TearDown() will be called immediately after each test.
virtual void TearDown();
-
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/LEB128Test.cpp b/unittests/LEB128Test.cpp
index b310262..97aa7d9 100644
--- a/unittests/LEB128Test.cpp
+++ b/unittests/LEB128Test.cpp
@@ -6,46 +6,41 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/Support/LEB128.h>
+#include "mcld/Support/LEB128.h"
#include "LEB128Test.h"
-#include <mcld/Support/SystemUtils.h>
+#include "mcld/Support/SystemUtils.h"
#include <ctime>
#include <cstdlib>
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-LEB128Test::LEB128Test()
-{
- // Initialize the seed for random number generator using during the tests.
+LEB128Test::LEB128Test() {
+ // Initialize the seed for random number generator using during the tests.
sys::SetRandomSeed(::time(NULL));
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-LEB128Test::~LEB128Test()
-{
+LEB128Test::~LEB128Test() {
}
// SetUp() will be called immediately before each test.
-void LEB128Test::SetUp()
-{
+void LEB128Test::SetUp() {
}
// TearDown() will be called immediately after each test.
-void LEB128Test::TearDown()
-{
+void LEB128Test::TearDown() {
}
//==========================================================================//
// Testcases
//
-TEST_F( LEB128Test, EncodeULEB_Example_from_Dwarf3_Figure22_Using_32bits) {
+TEST_F(LEB128Test, EncodeULEB_Example_from_Dwarf3_Figure22_Using_32bits) {
leb128::ByteType buffer[2];
- leb128::ByteType *result;
+ leb128::ByteType* result;
size_t size;
result = buffer;
@@ -89,9 +84,9 @@
ASSERT_TRUE(size == 2);
}
-TEST_F( LEB128Test, EncodeULEB_Example_from_Dwarf3_Figure22_Using_64bits) {
+TEST_F(LEB128Test, EncodeULEB_Example_from_Dwarf3_Figure22_Using_64bits) {
leb128::ByteType buffer[2];
- leb128::ByteType *result;
+ leb128::ByteType* result;
size_t size;
result = buffer;
@@ -135,9 +130,9 @@
ASSERT_TRUE(size == 2);
}
-TEST_F( LEB128Test, EncodeSLEB_Example_from_Dwarf3_Figure22) {
+TEST_F(LEB128Test, EncodeSLEB_Example_from_Dwarf3_Figure22) {
leb128::ByteType buffer[2];
- leb128::ByteType *result;
+ leb128::ByteType* result;
size_t size;
result = buffer;
@@ -195,7 +190,7 @@
ASSERT_TRUE(size == 2);
}
-TEST_F( LEB128Test, DecodeULEB_Example_from_Dwarf3_Figure22) {
+TEST_F(LEB128Test, DecodeULEB_Example_from_Dwarf3_Figure22) {
leb128::ByteType buffer[2];
size_t size;
@@ -228,10 +223,9 @@
buffer[1] = 100;
ASSERT_TRUE(leb128::decode<uint64_t>(buffer, size) == 12857);
ASSERT_TRUE(size == 2);
-
}
-TEST_F( LEB128Test, DecodeSLEB_Example_from_Dwarf3_Figure22) {
+TEST_F(LEB128Test, DecodeSLEB_Example_from_Dwarf3_Figure22) {
leb128::ByteType buffer[2];
size_t size;
@@ -276,9 +270,9 @@
ASSERT_TRUE(size == 2);
}
-TEST_F( LEB128Test, DecodeULEB_Tests_Found_in_Android_dalvik_dx) {
+TEST_F(LEB128Test, DecodeULEB_Tests_Found_in_Android_dalvik_dx) {
leb128::ByteType content[2];
- const leb128::ByteType *p;
+ const leb128::ByteType* p;
content[0] = 0;
p = content;
@@ -297,9 +291,9 @@
ASSERT_EQ(p, content + 2);
}
-TEST_F( LEB128Test, EncodeULEB_Tests_Found_in_Android_dalvik_dx) {
+TEST_F(LEB128Test, EncodeULEB_Tests_Found_in_Android_dalvik_dx) {
leb128::ByteType buffer[5];
- leb128::ByteType *result;
+ leb128::ByteType* result;
size_t size;
result = buffer;
@@ -389,9 +383,9 @@
ASSERT_TRUE(size == 5);
}
-TEST_F( LEB128Test, DecodeSLEB_Tests_Found_in_Android_dalvik_dx) {
+TEST_F(LEB128Test, DecodeSLEB_Tests_Found_in_Android_dalvik_dx) {
leb128::ByteType content[2];
- const leb128::ByteType *p;
+ const leb128::ByteType* p;
content[0] = 0;
p = content;
@@ -414,9 +408,9 @@
ASSERT_EQ(p, content + 1);
}
-TEST_F( LEB128Test, EncodeSLEB_Tests_Found_in_Android_dalvik_dx) {
+TEST_F(LEB128Test, EncodeSLEB_Tests_Found_in_Android_dalvik_dx) {
leb128::ByteType buffer[5];
- leb128::ByteType *result;
+ leb128::ByteType* result;
size_t size;
result = buffer;
@@ -456,14 +450,14 @@
ASSERT_TRUE(size == 1);
}
-TEST_F( LEB128Test, Random_Regression_Test) {
+TEST_F(LEB128Test, Random_Regression_Test) {
leb128::ByteType buffer[9];
for (int i = 0; i < 20; i++) {
unsigned long int value = sys::GetRandomNum();
uint64_t value2 = value * value;
int64_t value3 = value * value;
- leb128::ByteType *result;
+ leb128::ByteType* result;
size_t encode_size, decode_size;
// Test encode<uint32_t> and decode<uint64_t> on value
@@ -496,9 +490,9 @@
}
}
-TEST_F( LEB128Test, Other_Test) {
+TEST_F(LEB128Test, Other_Test) {
leb128::ByteType buffer[5];
- leb128::ByteType *result;
+ leb128::ByteType* result;
size_t size;
result = buffer;
@@ -512,9 +506,9 @@
ASSERT_TRUE(size == 3);
}
-TEST_F( LEB128Test, Type_Conversion_Test) {
+TEST_F(LEB128Test, Type_Conversion_Test) {
char buffer[5];
- char *result;
+ char* result;
size_t size;
result = buffer;
@@ -527,7 +521,7 @@
ASSERT_TRUE(leb128::decode<uint64_t>(buffer, size) == 154452);
ASSERT_TRUE(size == 3);
- const char *p = buffer;
+ const char* p = buffer;
ASSERT_TRUE(leb128::decode<uint64_t>(p) == 154452);
ASSERT_TRUE(p == (buffer + 3));
}
diff --git a/unittests/LEB128Test.h b/unittests/LEB128Test.h
index f0a87e3..07febff 100644
--- a/unittests/LEB128Test.h
+++ b/unittests/LEB128Test.h
@@ -11,31 +11,28 @@
#include <gtest.h>
-namespace mcldtest
-{
+namespace mcldtest {
/** \class LEB128Test
* \brief
*
* \see LEB
*/
-class LEB128Test : public ::testing::Test
-{
-public:
- // Constructor can do set-up work for all test here.
- LEB128Test();
+class LEB128Test : public ::testing::Test {
+ public:
+ // Constructor can do set-up work for all test here.
+ LEB128Test();
- // Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~LEB128Test();
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~LEB128Test();
- // SetUp() will be called immediately before each test.
- virtual void SetUp();
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
- // TearDown() will be called immediately after each test.
- virtual void TearDown();
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/LinearAllocatorTest.cpp b/unittests/LinearAllocatorTest.cpp
index d38684a..bc8092e 100644
--- a/unittests/LinearAllocatorTest.cpp
+++ b/unittests/LinearAllocatorTest.cpp
@@ -7,133 +7,127 @@
//
//===----------------------------------------------------------------------===//
#include "LinearAllocatorTest.h"
-#include <mcld/Support/Allocators.h>
+#include "mcld/Support/Allocators.h"
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-LinearAllocatorTest::LinearAllocatorTest()
-{
- // create testee. modify it if need
- m_pTestee = new LinearAllocator<Data, CHUNK_SIZE>();
+LinearAllocatorTest::LinearAllocatorTest() {
+ // create testee. modify it if need
+ m_pTestee = new LinearAllocator<Data, CHUNK_SIZE>();
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-LinearAllocatorTest::~LinearAllocatorTest()
-{
- delete m_pTestee;
+LinearAllocatorTest::~LinearAllocatorTest() {
+ delete m_pTestee;
}
// SetUp() will be called immediately before each test.
-void LinearAllocatorTest::SetUp()
-{
+void LinearAllocatorTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void LinearAllocatorTest::TearDown()
-{
+void LinearAllocatorTest::TearDown() {
}
//==========================================================================//
// Testcases
//
-TEST_F( LinearAllocatorTest, allocateN ) {
- Data* pointer = m_pTestee->allocate(10);
- ASSERT_FALSE(0 == pointer);
- ASSERT_EQ(CHUNK_SIZE, m_pTestee->max_size());
- ASSERT_FALSE(m_pTestee->empty());
+TEST_F(LinearAllocatorTest, allocateN) {
+ Data* pointer = m_pTestee->allocate(10);
+ ASSERT_FALSE(0 == pointer);
+ ASSERT_EQ(CHUNK_SIZE, m_pTestee->max_size());
+ ASSERT_FALSE(m_pTestee->empty());
}
-TEST_F( LinearAllocatorTest, allocate ) {
- Data* pointer = m_pTestee->allocate();
- ASSERT_FALSE(0 == pointer);
- ASSERT_EQ(CHUNK_SIZE, m_pTestee->max_size());
- ASSERT_FALSE(m_pTestee->empty());
+TEST_F(LinearAllocatorTest, allocate) {
+ Data* pointer = m_pTestee->allocate();
+ ASSERT_FALSE(0 == pointer);
+ ASSERT_EQ(CHUNK_SIZE, m_pTestee->max_size());
+ ASSERT_FALSE(m_pTestee->empty());
}
-TEST_F( LinearAllocatorTest, allocateOver ) {
- Data* pointer = m_pTestee->allocate(CHUNK_SIZE+1);
- ASSERT_TRUE(0 == pointer);
- ASSERT_TRUE(0 == m_pTestee->max_size());
- ASSERT_TRUE(m_pTestee->empty());
+TEST_F(LinearAllocatorTest, allocateOver) {
+ Data* pointer = m_pTestee->allocate(CHUNK_SIZE + 1);
+ ASSERT_TRUE(0 == pointer);
+ ASSERT_TRUE(0 == m_pTestee->max_size());
+ ASSERT_TRUE(m_pTestee->empty());
}
-TEST_F( LinearAllocatorTest, alloc_construct ) {
- Data* pointer = m_pTestee->allocate();
- m_pTestee->construct(pointer);
- ASSERT_TRUE(1 == pointer->one);
- ASSERT_TRUE(2 == pointer->two);
- ASSERT_TRUE(3 == pointer->three);
- ASSERT_TRUE(4 == pointer->four);
+TEST_F(LinearAllocatorTest, alloc_construct) {
+ Data* pointer = m_pTestee->allocate();
+ m_pTestee->construct(pointer);
+ ASSERT_TRUE(1 == pointer->one);
+ ASSERT_TRUE(2 == pointer->two);
+ ASSERT_TRUE(3 == pointer->three);
+ ASSERT_TRUE(4 == pointer->four);
}
-TEST_F( LinearAllocatorTest, alloc_constructCopy ) {
- Data* pointer = m_pTestee->allocate();
- Data data(7, 7, 7, 7);
- m_pTestee->construct(pointer, data);
-
- ASSERT_TRUE(7 == pointer->one);
- ASSERT_TRUE(7 == pointer->two);
- ASSERT_TRUE(7 == pointer->three);
- ASSERT_TRUE(7 == pointer->four);
+TEST_F(LinearAllocatorTest, alloc_constructCopy) {
+ Data* pointer = m_pTestee->allocate();
+ Data data(7, 7, 7, 7);
+ m_pTestee->construct(pointer, data);
+
+ ASSERT_TRUE(7 == pointer->one);
+ ASSERT_TRUE(7 == pointer->two);
+ ASSERT_TRUE(7 == pointer->three);
+ ASSERT_TRUE(7 == pointer->four);
}
-TEST_F( LinearAllocatorTest, allocN_construct ) {
- Data* pointer = m_pTestee->allocate(10);
- m_pTestee->construct(pointer);
- ASSERT_TRUE(1 == pointer->one);
- ASSERT_TRUE(2 == pointer->two);
- ASSERT_TRUE(3 == pointer->three);
- ASSERT_TRUE(4 == pointer->four);
+TEST_F(LinearAllocatorTest, allocN_construct) {
+ Data* pointer = m_pTestee->allocate(10);
+ m_pTestee->construct(pointer);
+ ASSERT_TRUE(1 == pointer->one);
+ ASSERT_TRUE(2 == pointer->two);
+ ASSERT_TRUE(3 == pointer->three);
+ ASSERT_TRUE(4 == pointer->four);
}
-TEST_F( LinearAllocatorTest, allocN_constructCopy ) {
- Data* pointer = m_pTestee->allocate(10);
- Data data(7, 7, 7, 7);
- m_pTestee->construct(pointer, data);
-
- ASSERT_TRUE(7 == pointer->one);
- ASSERT_TRUE(7 == pointer->two);
- ASSERT_TRUE(7 == pointer->three);
- ASSERT_TRUE(7 == pointer->four);
+TEST_F(LinearAllocatorTest, allocN_constructCopy) {
+ Data* pointer = m_pTestee->allocate(10);
+ Data data(7, 7, 7, 7);
+ m_pTestee->construct(pointer, data);
+
+ ASSERT_TRUE(7 == pointer->one);
+ ASSERT_TRUE(7 == pointer->two);
+ ASSERT_TRUE(7 == pointer->three);
+ ASSERT_TRUE(7 == pointer->four);
}
-TEST_F( LinearAllocatorTest, multi_alloc_ctor_iterate ) {
- for (int i=0; i<101; ++i) {
- Data* pointer = m_pTestee->allocate();
- m_pTestee->construct(pointer);
- pointer->one = i;
- }
-/**
- Alloc::iterator data, dEnd = m_pTestee->end();
- int counter = 0;
- for (data=m_pTestee->begin(); data!=dEnd; ++data) {
- ASSERT_EQ(counter, (*data).one);
- ++counter;
- }
-**/
+TEST_F(LinearAllocatorTest, multi_alloc_ctor_iterate) {
+ for (int i = 0; i < 101; ++i) {
+ Data* pointer = m_pTestee->allocate();
+ m_pTestee->construct(pointer);
+ pointer->one = i;
+ }
+ /**
+ Alloc::iterator data, dEnd = m_pTestee->end();
+ int counter = 0;
+ for (data=m_pTestee->begin(); data!=dEnd; ++data) {
+ ASSERT_EQ(counter, (*data).one);
+ ++counter;
+ }
+ **/
}
-TEST_F( LinearAllocatorTest, multi_allocN_ctor_iterate ) {
- int counter = 0;
- for (int i=0; i<10000; ++i) {
- Data* pointer = m_pTestee->allocate(10);
- for (int j=0; j<10; ++j) {
- m_pTestee->construct(pointer);
- pointer->one = counter;
- ++pointer;
- ++counter;
- }
- }
-/**
- Alloc::iterator data, dEnd = m_pTestee->end();
- counter = 0;
- for (data=m_pTestee->begin(); data!=dEnd; ++data) {
- ASSERT_EQ(counter, (*data).one);
- ++counter;
- }
-**/
+TEST_F(LinearAllocatorTest, multi_allocN_ctor_iterate) {
+ int counter = 0;
+ for (int i = 0; i < 10000; ++i) {
+ Data* pointer = m_pTestee->allocate(10);
+ for (int j = 0; j < 10; ++j) {
+ m_pTestee->construct(pointer);
+ pointer->one = counter;
+ ++pointer;
+ ++counter;
+ }
+ }
+ /**
+ Alloc::iterator data, dEnd = m_pTestee->end();
+ counter = 0;
+ for (data=m_pTestee->begin(); data!=dEnd; ++data) {
+ ASSERT_EQ(counter, (*data).one);
+ ++counter;
+ }
+ **/
}
-
diff --git a/unittests/LinearAllocatorTest.h b/unittests/LinearAllocatorTest.h
index 24b8715..fd9db10 100644
--- a/unittests/LinearAllocatorTest.h
+++ b/unittests/LinearAllocatorTest.h
@@ -12,64 +12,62 @@
#include <gtest.h>
#include "mcld/Support/Allocators.h"
-namespace mcldtest
-{
+namespace mcldtest {
/** \class LinearAllocatorTest
* \brief The testcase for LinearAllocator
*
* \see LinearAllocator
*/
-class LinearAllocatorTest : public ::testing::Test
-{
-public:
- struct Data {
- Data()
- : one(1), two(2), three(3), four(4)
- { }
+class LinearAllocatorTest : public ::testing::Test {
+ public:
+ struct Data {
+ Data() : one(1), two(2), three(3), four(4) {}
- Data( unsigned int pOne, unsigned int pTwo, unsigned char pThree, unsigned char pFour)
- {
- one = pOne;
- two = pTwo;
- three = pThree;
- four = pFour;
- }
+ Data(unsigned int pOne,
+ unsigned int pTwo,
+ unsigned char pThree,
+ unsigned char pFour) {
+ one = pOne;
+ two = pTwo;
+ three = pThree;
+ four = pFour;
+ }
- ~Data()
- {
- one = -1;
- two = -2;
- three = -3;
- four = -4;
- }
+ ~Data() {
+ one = -1;
+ two = -2;
+ three = -3;
+ four = -4;
+ }
- unsigned int one;
- unsigned int two;
- unsigned char three;
- unsigned char four;
- };
-public:
- // Constructor can do set-up work for all test here.
- LinearAllocatorTest();
+ unsigned int one;
+ unsigned int two;
+ unsigned char three;
+ unsigned char four;
+ };
- // Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~LinearAllocatorTest();
+ public:
+ // Constructor can do set-up work for all test here.
+ LinearAllocatorTest();
- // SetUp() will be called immediately before each test.
- virtual void SetUp();
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~LinearAllocatorTest();
- // TearDown() will be called immediately after each test.
- virtual void TearDown();
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
-protected:
- enum TemplateArgsType { CHUNK_SIZE = 32 };
- typedef mcld::LinearAllocator<Data, CHUNK_SIZE> Alloc;
-protected:
- Alloc* m_pTestee;
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
+
+ protected:
+ enum TemplateArgsType { CHUNK_SIZE = 32 };
+ typedef mcld::LinearAllocator<Data, CHUNK_SIZE> Alloc;
+
+ protected:
+ Alloc* m_pTestee;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/LinkerTest.cpp b/unittests/LinkerTest.cpp
index f9d3224..2af4913 100644
--- a/unittests/LinkerTest.cpp
+++ b/unittests/LinkerTest.cpp
@@ -8,15 +8,15 @@
//===----------------------------------------------------------------------===//
#include "LinkerTest.h"
-#include <mcld/Environment.h>
-#include <mcld/Module.h>
-#include <mcld/InputTree.h>
-#include <mcld/IRBuilder.h>
-#include <mcld/Linker.h>
-#include <mcld/LinkerConfig.h>
-#include <mcld/LinkerScript.h>
+#include "mcld/Environment.h"
+#include "mcld/Module.h"
+#include "mcld/InputTree.h"
+#include "mcld/IRBuilder.h"
+#include "mcld/Linker.h"
+#include "mcld/LinkerConfig.h"
+#include "mcld/LinkerScript.h"
-#include <mcld/Support/Path.h>
+#include "mcld/Support/Path.h"
#include <llvm/Support/ELF.h>
@@ -24,32 +24,26 @@
using namespace mcld::test;
using namespace mcld::sys::fs;
-
// Constructor can do set-up work for all test here.
-LinkerTest::LinkerTest()
-{
+LinkerTest::LinkerTest() {
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-LinkerTest::~LinkerTest()
-{
+LinkerTest::~LinkerTest() {
}
// SetUp() will be called immediately before each test.
-void LinkerTest::SetUp()
-{
+void LinkerTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void LinkerTest::TearDown()
-{
+void LinkerTest::TearDown() {
}
//===----------------------------------------------------------------------===//
// Testcases
//===----------------------------------------------------------------------===//
-TEST_F( LinkerTest, set_up_n_clean_up) {
-
+TEST_F(LinkerTest, set_up_n_clean_up) {
Initialize();
LinkerConfig config("arm-none-linux-gnueabi");
LinkerScript script;
@@ -77,8 +71,7 @@
// -lm -llog -ljnigraphics -lc
// %p/../../../libs/ARM/Android/android-14/crtend_so.o
// -o libplasma.so
-TEST_F( LinkerTest, plasma) {
-
+TEST_F(LinkerTest, plasma) {
Initialize();
Linker linker;
LinkerScript script;
@@ -124,7 +117,7 @@
builder.ReadInput("crtend", crtend);
if (linker.link(module, builder)) {
- linker.emit(module, "libplasma.so"); ///< -o libplasma.so
+ linker.emit(module, "libplasma.so"); ///< -o libplasma.so
}
Finalize();
@@ -132,11 +125,11 @@
// The outputs generated without -Bsymbolic usually have more relocation
// entries than the outputs generated with -Bsymbolic. This testcase generates
-// output with -Bsymbolic first, then generate the same output without -Bsymbolic.
+// output with -Bsymbolic first, then generate the same output without
+// -Bsymbolic.
// By this way, we can make sure symbols and relocations are cleaned between
// two linkings.
-TEST_F( LinkerTest, plasma_twice) {
-
+TEST_F(LinkerTest, plasma_twice) {
Initialize();
Linker linker;
@@ -154,8 +147,9 @@
linker.emulate(script1, config1);
config1.setCodeGenType(LinkerConfig::DynObj); ///< --shared
- config1.options().setSOName("libplasma.once.so"); ///< --soname=libplasma.twice.so
- config1.options().setBsymbolic(false); ///< -Bsymbolic
+ config1.options().setSOName(
+ "libplasma.once.so"); ///< --soname=libplasma.twice.so
+ config1.options().setBsymbolic(false); ///< -Bsymbolic
Module module1("libplasma.once.so", script1);
IRBuilder builder1(module1, config1);
@@ -182,7 +176,7 @@
builder1.ReadInput("crtend", crtend);
if (linker.link(module1, builder1)) {
- linker.emit(module1, "libplasma.once.so"); ///< -o libplasma.so
+ linker.emit(module1, "libplasma.once.so"); ///< -o libplasma.so
}
Finalize();
@@ -203,8 +197,9 @@
linker.emulate(script2, config2);
config2.setCodeGenType(LinkerConfig::DynObj); ///< --shared
- config2.options().setSOName("libplasma.twice.so"); ///< --soname=libplasma.twice.exe
- config2.options().setBsymbolic(); ///< -Bsymbolic
+ config2.options().setSOName(
+ "libplasma.twice.so"); ///< --soname=libplasma.twice.exe
+ config2.options().setBsymbolic(); ///< -Bsymbolic
Module module2("libplasma.so", script2);
IRBuilder builder2(module2, config2);
@@ -225,15 +220,14 @@
builder2.ReadInput("crtend", crtend);
if (linker.link(module2, builder2)) {
- linker.emit(module2, "libplasma.twice.so"); ///< -o libplasma.exe
+ linker.emit(module2, "libplasma.twice.so"); ///< -o libplasma.exe
}
Finalize();
}
// This testcase put IRBuilder in the heap
-TEST_F( LinkerTest, plasma_twice_irbuilder_heap) {
-
+TEST_F(LinkerTest, plasma_twice_irbuilder_heap) {
Initialize();
Linker linker;
@@ -251,11 +245,12 @@
linker.emulate(script1, config1);
config1.setCodeGenType(LinkerConfig::DynObj); ///< --shared
- config1.options().setSOName("libplasma.once.so"); ///< --soname=libplasma.twice.so
- config1.options().setBsymbolic(false); ///< -Bsymbolic
+ config1.options().setSOName(
+ "libplasma.once.so"); ///< --soname=libplasma.twice.so
+ config1.options().setBsymbolic(false); ///< -Bsymbolic
Module module1("libplasma.once.so", script1);
- IRBuilder *builder1 = new IRBuilder(module1, config1);
+ IRBuilder* builder1 = new IRBuilder(module1, config1);
/// ${TOPDIR}/test/libs/ARM/Android/android-14/crtbegin_so.o
Path crtbegin(search_dir);
@@ -279,7 +274,7 @@
builder1->ReadInput("crtend", crtend);
if (linker.link(module1, *builder1)) {
- linker.emit(module1, "libplasma.once.so"); ///< -o libplasma.so
+ linker.emit(module1, "libplasma.once.so"); ///< -o libplasma.so
}
// Can not delete builder until emit the output. Dynamic string table
@@ -305,8 +300,9 @@
linker.emulate(script2, config2);
config2.setCodeGenType(LinkerConfig::DynObj); ///< --shared
- config2.options().setSOName("libplasma.twice.so"); ///< --soname=libplasma.twice.exe
- config2.options().setBsymbolic(); ///< -Bsymbolic
+ config2.options().setSOName(
+ "libplasma.twice.so"); ///< --soname=libplasma.twice.exe
+ config2.options().setBsymbolic(); ///< -Bsymbolic
Module module2("libplasma.so", script2);
IRBuilder* builder2 = new IRBuilder(module2, config2);
@@ -327,7 +323,7 @@
builder2->ReadInput("crtend", crtend);
if (linker.link(module2, *builder2)) {
- linker.emit(module2, "libplasma.twice.so"); ///< -o libplasma.exe
+ linker.emit(module2, "libplasma.twice.so"); ///< -o libplasma.exe
}
delete builder2;
@@ -336,8 +332,7 @@
// %MCLinker --shared -soname=libgotplt.so -mtriple arm-none-linux-gnueabi
// gotplt.o -o libgotplt.so
-TEST_F( LinkerTest, plasma_object) {
-
+TEST_F(LinkerTest, plasma_object) {
Initialize();
Linker linker;
@@ -360,96 +355,127 @@
Input* input = builder.CreateInput("gotplt.o", gotplt_o, Input::Object);
/// Sections
- /// [ 0] NULL 00000000 000000 000000 00 0 0 0
- builder.CreateELFHeader(*input,
- "",
- LDFileFormat::Null,
- llvm::ELF::SHT_NULL,
- 0x0);
+ /// [ 0] NULL 00000000 000000 000000 00 0
+ /// 0 0
+ builder.CreateELFHeader(
+ *input, "", LDFileFormat::Null, llvm::ELF::SHT_NULL, 0x0);
- /// [ 1] .text PROGBITS 00000000 000034 000010 00 AX 0 0 4
- LDSection* text = builder.CreateELFHeader(*input,
+ /// [ 1] .text PROGBITS 00000000 000034 000010 00 AX 0
+ /// 0 4
+ LDSection* text =
+ builder.CreateELFHeader(*input,
".text",
llvm::ELF::SHT_PROGBITS,
llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_EXECINSTR,
4);
SectionData* text_data = builder.CreateSectionData(*text);
- static uint8_t text_content[] = { 0x00, 0x48, 0x2d, 0xe9,
- 0xfe, 0xff, 0xff, 0xeb,
- 0x00, 0x48, 0xbd, 0xe8,
- 0x0e, 0xf0, 0xa0, 0xe1 };
+ static uint8_t text_content[] = {
+ 0x00, 0x48, 0x2d, 0xe9,
+ 0xfe, 0xff, 0xff, 0xeb,
+ 0x00, 0x48, 0xbd, 0xe8,
+ 0x0e, 0xf0, 0xa0, 0xe1
+ };
+
Fragment* text_frag = builder.CreateRegion(text_content, 0x10);
builder.AppendFragment(*text_frag, *text_data);
- /// [ 2] .rel.text REL 00000000 0002ac 000008 08 7 1 4
- LDSection* rel_text = builder.CreateELFHeader(*input,
- ".rel.text",
- llvm::ELF::SHT_REL,
- 0x0, 4);
+ /// [ 2] .rel.text REL 00000000 0002ac 000008 08 7
+ /// 1 4
+ LDSection* rel_text =
+ builder.CreateELFHeader(*input, ".rel.text", llvm::ELF::SHT_REL, 0x0, 4);
rel_text->setLink(text);
builder.CreateRelocData(*rel_text);
- /// [ 3] .data PROGBITS 00000000 000044 000000 00 WA 0 0 4
- LDSection* data = builder.CreateELFHeader(*input,
- ".data",
- llvm::ELF::SHT_PROGBITS,
- llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE,
- 4);
+ /// [ 3] .data PROGBITS 00000000 000044 000000 00 WA 0
+ /// 0 4
+ LDSection* data =
+ builder.CreateELFHeader(*input,
+ ".data",
+ llvm::ELF::SHT_PROGBITS,
+ llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE,
+ 4);
- /// [ 4] .bss NOBITS 00000000 000044 000000 00 WA 0 0 4
- LDSection* bss = builder.CreateELFHeader(*input,
- ".bss",
- llvm::ELF::SHT_NOBITS,
- llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE,
- 4);
+ /// [ 4] .bss NOBITS 00000000 000044 000000 00 WA 0
+ /// 0 4
+ LDSection* bss =
+ builder.CreateELFHeader(*input,
+ ".bss",
+ llvm::ELF::SHT_NOBITS,
+ llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE,
+ 4);
builder.CreateBSS(*bss);
- /// [ 5] .ARM.attributes ARM_ATTRIBUTES 00000000 000044 000020 00 0 0 1
- LDSection* attr = builder.CreateELFHeader(*input,
- ".ARM.attributes",
- llvm::ELF::SHT_ARM_ATTRIBUTES,
- 0x0,
- 1);
+ /// [ 5] .ARM.attributes ARM_ATTRIBUTES 00000000 000044 000020 00 0
+ /// 0 1
+ LDSection* attr = builder.CreateELFHeader(
+ *input, ".ARM.attributes", llvm::ELF::SHT_ARM_ATTRIBUTES, 0x0, 1);
SectionData* attr_data = builder.CreateSectionData(*attr);
static uint8_t attr_content[] = {
- 0x41, 0x1f, 0x00, 0x00,
- 0x00, 0x61, 0x65, 0x61,
- 0x62, 0x69, 0x00, 0x01,
- 0x15, 0x00, 0x00, 0x00,
- 0x06, 0x02, 0x08, 0x01,
- 0x09, 0x01, 0x14, 0x01,
- 0x15, 0x01, 0x17, 0x03,
- 0x18, 0x01, 0x19, 0x01 };
+ 0x41, 0x1f, 0x00, 0x00,
+ 0x00, 0x61, 0x65, 0x61,
+ 0x62, 0x69, 0x00, 0x01,
+ 0x15, 0x00, 0x00, 0x00,
+ 0x06, 0x02, 0x08, 0x01,
+ 0x09, 0x01, 0x14, 0x01,
+ 0x15, 0x01, 0x17, 0x03,
+ 0x18, 0x01, 0x19, 0x01
+ };
+
Fragment* attr_frag = builder.CreateRegion(attr_content, 0x20);
builder.AppendFragment(*attr_frag, *attr_data);
/// Symbols
/// 1: 00000000 0 FILE LOCAL DEFAULT ABS Output/gotplt.bc
builder.AddSymbol(*input,
- "Output/gotplt.bc", ResolveInfo::File,
- ResolveInfo::Define, ResolveInfo::Local, 0);
+ "Output/gotplt.bc",
+ ResolveInfo::File,
+ ResolveInfo::Define,
+ ResolveInfo::Local,
+ 0);
/// 2: 00000000 0 SECTION LOCAL DEFAULT 1
builder.AddSymbol(*input,
- ".text", ResolveInfo::Section,
- ResolveInfo::Define, ResolveInfo::Local, 0, 0x0, text);
+ ".text",
+ ResolveInfo::Section,
+ ResolveInfo::Define,
+ ResolveInfo::Local,
+ 0,
+ 0x0,
+ text);
/// 3: 00000000 0 SECTION LOCAL DEFAULT 3
builder.AddSymbol(*input,
- ".data", ResolveInfo::Section,
- ResolveInfo::Define, ResolveInfo::Local, 0, 0x0, data);
+ ".data",
+ ResolveInfo::Section,
+ ResolveInfo::Define,
+ ResolveInfo::Local,
+ 0,
+ 0x0,
+ data);
/// 4: 00000000 0 SECTION LOCAL DEFAULT 4
builder.AddSymbol(*input,
- ".bss", ResolveInfo::Section,
- ResolveInfo::Define, ResolveInfo::Local, 0, 0x0, bss);
+ ".bss",
+ ResolveInfo::Section,
+ ResolveInfo::Define,
+ ResolveInfo::Local,
+ 0,
+ 0x0,
+ bss);
/// 5: 00000000 0 SECTION LOCAL DEFAULT 5
builder.AddSymbol(*input,
- ".ARM.attributes", ResolveInfo::Section,
- ResolveInfo::Define, ResolveInfo::Local, 0, 0x0, attr);
+ ".ARM.attributes",
+ ResolveInfo::Section,
+ ResolveInfo::Define,
+ ResolveInfo::Local,
+ 0,
+ 0x0,
+ attr);
/// 6: 00000000 16 FUNC GLOBAL DEFAULT 1 _Z1fv
builder.AddSymbol(*input,
- "_Z1fv", ResolveInfo::Function,
- ResolveInfo::Define, ResolveInfo::Global,
+ "_Z1fv",
+ ResolveInfo::Function,
+ ResolveInfo::Define,
+ ResolveInfo::Global,
16,
0x0,
text);
@@ -462,13 +488,13 @@
ResolveInfo::Global,
0);
- /// Relocations
- /// Offset Info Type Sym.Value Sym. Name
- /// 00000004 0000071b R_ARM_PLT32 00000000 _Z1gv
- builder.AddRelocation(*rel_text, llvm::ELF::R_ARM_PLT32, *z1gv, 0x4);
+ /// Relocations
+ /// Offset Info Type Sym.Value Sym. Name
+ /// 00000004 0000071b R_ARM_PLT32 00000000 _Z1gv
+ builder.AddRelocation(*rel_text, llvm::ELF::R_ARM_PLT32, *z1gv, 0x4);
if (linker.link(module, builder)) {
- linker.emit(module, "libgotplt.so"); ///< -o libgotplt.so
+ linker.emit(module, "libgotplt.so"); ///< -o libgotplt.so
}
Finalize();
diff --git a/unittests/LinkerTest.h b/unittests/LinkerTest.h
index cb60d40..f20fd62 100644
--- a/unittests/LinkerTest.h
+++ b/unittests/LinkerTest.h
@@ -17,9 +17,8 @@
namespace test {
-class LinkerTest : public ::testing::Test
-{
-public:
+class LinkerTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
LinkerTest();
@@ -33,8 +32,7 @@
virtual void TearDown();
};
-} // namespace of test
-} // namespace for mcld
+} // namespace of test
+} // namespace for mcld
#endif
-
diff --git a/unittests/MCRegionFragmentTest.cpp b/unittests/MCRegionFragmentTest.cpp
index 7d6c3b9..0319845 100644
--- a/unittests/MCRegionFragmentTest.cpp
+++ b/unittests/MCRegionFragmentTest.cpp
@@ -9,47 +9,42 @@
#include "MCRegionFragmentTest.h"
-#include <mcld/MC/MCRegionFragment.h>
-#include <mcld/Support/MemoryAreaFactory.h>
-#include <mcld/Support/Path.h>
+#include "mcld/MC/MCRegionFragment.h"
+#include "mcld/Support/MemoryAreaFactory.h"
+#include "mcld/Support/Path.h"
using namespace mcld;
using namespace mcldtest;
using namespace mcld::sys::fs;
-
// Constructor can do set-up work for all test here.
-MCRegionFragmentTest::MCRegionFragmentTest()
-{
+MCRegionFragmentTest::MCRegionFragmentTest() {
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-MCRegionFragmentTest::~MCRegionFragmentTest()
-{
+MCRegionFragmentTest::~MCRegionFragmentTest() {
}
// SetUp() will be called immediately before each test.
-void MCRegionFragmentTest::SetUp()
-{
+void MCRegionFragmentTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void MCRegionFragmentTest::TearDown()
-{
+void MCRegionFragmentTest::TearDown() {
}
//==========================================================================//
// Testcases
//
-TEST_F( MCRegionFragmentTest, classof_explicit ) {
+TEST_F(MCRegionFragmentTest, classof_explicit) {
Path path(TOPDIR);
path.append("unittests/test3.txt");
MemoryAreaFactory* areaFactory = new MemoryAreaFactory(1);
MemoryArea* area = areaFactory->produce(path, MemoryArea::ReadWrite);
MemoryRegion* region = area->request(0, 4096);
- MCRegionFragment *frag = new MCRegionFragment(*region);
+ MCRegionFragment* frag = new MCRegionFragment(*region);
ASSERT_FALSE(llvm::MCDataFragment::classof(frag));
ASSERT_TRUE(MCRegionFragment::classof(frag));
@@ -57,18 +52,17 @@
delete areaFactory;
}
-TEST_F( MCRegionFragmentTest, classof_implicit ) {
+TEST_F(MCRegionFragmentTest, classof_implicit) {
Path path(TOPDIR);
path.append("unittests/test3.txt");
MemoryAreaFactory* areaFactory = new MemoryAreaFactory(1);
MemoryArea* area = areaFactory->produce(path, MemoryArea::ReadWrite);
MemoryRegion* region = area->request(0, 4096);
- llvm::MCFragment *frag = new MCRegionFragment(*region);
+ llvm::MCFragment* frag = new MCRegionFragment(*region);
ASSERT_FALSE(llvm::MCDataFragment::classof(frag));
ASSERT_TRUE(MCRegionFragment::classof(frag));
delete frag;
delete areaFactory;
}
-
diff --git a/unittests/MCRegionFragmentTest.h b/unittests/MCRegionFragmentTest.h
index 3d1dab8..5b9e00b 100644
--- a/unittests/MCRegionFragmentTest.h
+++ b/unittests/MCRegionFragmentTest.h
@@ -12,40 +12,36 @@
#include <gtest.h>
-namespace mcld
-{
+namespace mcld {
class MCRegionFragment;
-} // namespace for mcld
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
/** \class MCRegionFragmentTest
* \brief The testcase of MCRegionFragment.
*
* \see MCRegionFragment
*/
-class MCRegionFragmentTest : public ::testing::Test
-{
-public:
- // Constructor can do set-up work for all test here.
- MCRegionFragmentTest();
+class MCRegionFragmentTest : public ::testing::Test {
+ public:
+ // Constructor can do set-up work for all test here.
+ MCRegionFragmentTest();
- // Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~MCRegionFragmentTest();
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~MCRegionFragmentTest();
- // SetUp() will be called immediately before each test.
- virtual void SetUp();
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
- // TearDown() will be called immediately after each test.
- virtual void TearDown();
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
-protected:
- mcld::MCRegionFragment* m_pTestee;
+ protected:
+ mcld::MCRegionFragment* m_pTestee;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/NamePoolTest.cpp b/unittests/NamePoolTest.cpp
index 614ee6a..57c78fe 100644
--- a/unittests/NamePoolTest.cpp
+++ b/unittests/NamePoolTest.cpp
@@ -7,11 +7,11 @@
//
//===----------------------------------------------------------------------===//
#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 "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>
@@ -19,45 +19,39 @@
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-NamePoolTest::NamePoolTest()
-{
+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()
-{
+NamePoolTest::~NamePoolTest() {
delete m_pTestee;
}
// SetUp() will be called immediately before each test.
-void NamePoolTest::SetUp()
-{
+void NamePoolTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void NamePoolTest::TearDown()
-{
+void NamePoolTest::TearDown() {
}
//==========================================================================//
// Testcases
//
-
-TEST_F( NamePoolTest, insertString ) {
- const char *s1 = "Hello MCLinker";
+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";
+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());
@@ -66,8 +60,8 @@
EXPECT_EQ(result1.data(), result2.data());
}
-TEST_F( NamePoolTest, insert_local_defined_Symbol ) {
- const char *name = "Hello MCLinker";
+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;
@@ -76,15 +70,8 @@
uint64_t size = 0;
ResolveInfo::Visibility other = ResolveInfo::Default;
Resolver::Result result1;
- m_pTestee->insertSymbol(name,
- isDyn,
- type,
- desc,
- binding,
- size,
- other,
- NULL,
- 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());
@@ -96,15 +83,8 @@
EXPECT_EQ(other, result1.info->visibility());
Resolver::Result result2;
- m_pTestee->insertSymbol(name,
- isDyn,
- type,
- desc,
- binding,
- size,
- other,
- NULL,
- 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());
@@ -118,8 +98,8 @@
EXPECT_NE(result1.existent, result2.existent);
}
-TEST_F( NamePoolTest, insert_global_reference_Symbol ) {
- const char *name = "Hello MCLinker";
+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;
@@ -127,15 +107,8 @@
uint64_t size = 0;
ResolveInfo::Visibility other = ResolveInfo::Default;
Resolver::Result result1;
- m_pTestee->insertSymbol(name,
- isDyn,
- type,
- desc,
- binding,
- size,
- other,
- NULL,
- 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());
@@ -147,15 +120,8 @@
EXPECT_EQ(other, result1.info->visibility());
Resolver::Result result2;
- m_pTestee->insertSymbol(name,
- isDyn,
- type,
- desc,
- binding,
- size,
- other,
- NULL,
- result2);
+ m_pTestee->insertSymbol(
+ name, isDyn, type, desc, binding, size, other, NULL, result2);
EXPECT_EQ(result1.info, result2.info);
@@ -170,98 +136,71 @@
NULL,
result3);
-
EXPECT_NE(result1.info, result3.info);
}
-
-TEST_F( NamePoolTest, insertSymbol_after_insert_same_string ) {
- const char *name = "Hello MCLinker";
+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;
+ 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);
+ 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);
+ 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 ) {
+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;
+ 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) {
+ LDSymbol* syms[128][128];
+ for (int i = 0; i < 128; ++i) {
name[0] = i;
- for(int j=0; j<128 ;++j) {
+ for (int j = 0; j < 128; ++j) {
name[1] = j;
- syms[i][j] = m_pTestee->insertSymbol(name,
- isDyn,
- type,
- binding,
- section,
- value,
- size,
- other);
+ 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) {
+ for (int i = 127; i >= 0; --i) {
name[0] = i;
- for(int j=0; j<128 ;++j) {
+ for (int j = 0; j < 128; ++j) {
name[1] = j;
- LDSymbol *sym = m_pTestee->insertSymbol(name,
- isDyn,
- type,
- binding,
- section,
- value,
- size,
- other);
+ 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) {
+ for (int i = 0; i < 128; ++i) {
name[0] = i;
- for(int j=0; j<128 ;++j) {
+ for (int j = 0; j < 128; ++j) {
name[1] = j;
- LDSymbol *sym = m_pTestee->insertSymbol(name,
- isDyn,
- type,
- binding,
- section,
- value,
- size,
- other);
+ LDSymbol* sym = m_pTestee->insertSymbol(
+ name, isDyn, type, binding, section, value, size, other);
ASSERT_EQ(sym, syms[i][j]);
}
}
diff --git a/unittests/NamePoolTest.h b/unittests/NamePoolTest.h
index 2e4a494..8c63dac 100644
--- a/unittests/NamePoolTest.h
+++ b/unittests/NamePoolTest.h
@@ -11,40 +11,36 @@
#include <gtest.h>
-namespace mcld
-{
+namespace mcld {
class NamePool;
-} // namespace for mcld
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
/** \class NamePoolTest
* \brief
*
* \see NamePool
*/
-class NamePoolTest : public ::testing::Test
-{
-public:
- // Constructor can do set-up work for all test here.
- NamePoolTest();
+class NamePoolTest : public ::testing::Test {
+ public:
+ // Constructor can do set-up work for all test here.
+ NamePoolTest();
- // Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~NamePoolTest();
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~NamePoolTest();
- // SetUp() will be called immediately before each test.
- virtual void SetUp();
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
- // TearDown() will be called immediately after each test.
- virtual void TearDown();
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
-protected:
- mcld::NamePool* m_pTestee;
+ protected:
+ mcld::NamePool* m_pTestee;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/PathSetTest.cpp b/unittests/PathSetTest.cpp
index d735e9c..b5f7b21 100644
--- a/unittests/PathSetTest.cpp
+++ b/unittests/PathSetTest.cpp
@@ -12,34 +12,28 @@
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-PathSetTest::PathSetTest()
-{
- // create testee. modify it if need
- m_pTestee = new PathSet();
+PathSetTest::PathSetTest() {
+ // create testee. modify it if need
+ m_pTestee = new PathSet();
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-PathSetTest::~PathSetTest()
-{
- delete m_pTestee;
+PathSetTest::~PathSetTest() {
+ delete m_pTestee;
}
// SetUp() will be called immediately before each test.
-void PathSetTest::SetUp()
-{
+void PathSetTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void PathSetTest::TearDown()
-{
+void PathSetTest::TearDown() {
}
//==========================================================================//
// Testcases
//
-TEST_F( PathSetTest, ) {
+TEST_F(PathSetTest, ) {
}
-
diff --git a/unittests/PathSetTest.h b/unittests/PathSetTest.h
index 23a2dbf..aee9758 100644
--- a/unittests/PathSetTest.h
+++ b/unittests/PathSetTest.h
@@ -11,40 +11,36 @@
#include <gtest.h>
-namespace mcld
-{
+namespace mcld {
class PathSet;
-} // namespace for mcld
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
/** \class PathSetTest
* \brief The testcase of PathSet
*
* \see PathSet
*/
-class PathSetTest : public ::testing::Test
-{
-public:
- // Constructor can do set-up work for all test here.
- PathSetTest();
+class PathSetTest : public ::testing::Test {
+ public:
+ // Constructor can do set-up work for all test here.
+ PathSetTest();
- // Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~PathSetTest();
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~PathSetTest();
- // SetUp() will be called immediately before each test.
- virtual void SetUp();
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
- // TearDown() will be called immediately after each test.
- virtual void TearDown();
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
-protected:
- mcld::PathSet* m_pTestee;
+ protected:
+ mcld::PathSet* m_pTestee;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/PathTest.cpp b/unittests/PathTest.cpp
index 73e62cc..b22788e 100644
--- a/unittests/PathTest.cpp
+++ b/unittests/PathTest.cpp
@@ -7,7 +7,7 @@
//
//===----------------------------------------------------------------------===//
#include "PathTest.h"
-#include <mcld/Support/FileSystem.h>
+#include "mcld/Support/FileSystem.h"
#include <string>
//
@@ -15,34 +15,29 @@
using namespace mcld::sys::fs;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-PathTest::PathTest()
-{
- // create testee. modify it if need
- m_pTestee = new Path();
+PathTest::PathTest() {
+ // create testee. modify it if need
+ m_pTestee = new Path();
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-PathTest::~PathTest()
-{
- delete m_pTestee;
+PathTest::~PathTest() {
+ delete m_pTestee;
}
// SetUp() will be called immediately before each test.
-void PathTest::SetUp()
-{
+void PathTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void PathTest::TearDown()
-{
+void PathTest::TearDown() {
}
//==========================================================================//
// Testcases
//
-TEST_F( PathTest, should_exist ) {
+TEST_F(PathTest, should_exist) {
std::string root(TOPDIR);
root += "/test/lit.cfg";
m_pTestee->assign(root);
@@ -53,7 +48,7 @@
EXPECT_TRUE(exists(*m_pTestee));
}
-TEST_F( PathTest, should_not_exist ) {
+TEST_F(PathTest, should_not_exist) {
const std::string root = "/luck";
m_pTestee->assign(root);
EXPECT_FALSE(exists(*m_pTestee));
@@ -63,7 +58,7 @@
EXPECT_FALSE(exists(*m_pTestee));
}
-TEST_F( PathTest, should_is_directory ) {
+TEST_F(PathTest, should_is_directory) {
const std::string root = "../././..";
m_pTestee->assign(root);
EXPECT_TRUE(exists(*m_pTestee));
@@ -74,7 +69,7 @@
EXPECT_TRUE(is_directory(*m_pTestee));
}
-TEST_F( PathTest, should_not_is_directory ) {
+TEST_F(PathTest, should_not_is_directory) {
const std::string root = "/luck";
m_pTestee->assign(root);
EXPECT_FALSE(exists(*m_pTestee));
@@ -85,60 +80,59 @@
EXPECT_FALSE(is_directory(*m_pTestee));
}
-TEST_F( PathTest, should_equal ) {
+TEST_F(PathTest, should_equal) {
const std::string root = "aaa/bbb/../../ccc/";
m_pTestee->assign(root);
Path* p2 = new Path("ccc///////");
- EXPECT_TRUE(*m_pTestee==*p2);
+ EXPECT_TRUE(*m_pTestee == *p2);
delete m_pTestee;
m_pTestee = new Path(root);
- EXPECT_TRUE(*m_pTestee==*m_pTestee);
+ EXPECT_TRUE(*m_pTestee == *m_pTestee);
delete p2;
}
-TEST_F( PathTest, should_not_equal ) {
+TEST_F(PathTest, should_not_equal) {
const std::string root = "aa/";
- Path* p2=new Path("aaa//");
-// p2->assign(root);
+ Path* p2 = new Path("aaa//");
+ // p2->assign(root);
m_pTestee->assign(root);
- EXPECT_TRUE(*m_pTestee!=*p2);
+ EXPECT_TRUE(*m_pTestee != *p2);
delete m_pTestee;
m_pTestee = new Path(root);
- EXPECT_TRUE(*m_pTestee!=*p2);
+ EXPECT_TRUE(*m_pTestee != *p2);
delete p2;
}
-TEST_F( PathTest, append_success ) {
-
+TEST_F(PathTest, append_success) {
const std::string root = "aa/";
m_pTestee->assign(root);
m_pTestee->append("aaa");
std::string a("aa/aaa");
- EXPECT_TRUE(m_pTestee->native()=="aa/aaa");
+ EXPECT_TRUE(m_pTestee->native() == "aa/aaa");
delete m_pTestee;
m_pTestee = new Path("aa/");
m_pTestee->append("/aaa");
- EXPECT_TRUE(m_pTestee->native()=="aa/aaa");
+ EXPECT_TRUE(m_pTestee->native() == "aa/aaa");
delete m_pTestee;
m_pTestee = new Path("aa");
m_pTestee->append("/aaa");
- EXPECT_TRUE(m_pTestee->native()=="aa/aaa");
+ EXPECT_TRUE(m_pTestee->native() == "aa/aaa");
delete m_pTestee;
m_pTestee = new Path("aa");
m_pTestee->append("aaa");
- EXPECT_TRUE(m_pTestee->native()=="aa/aaa");
+ EXPECT_TRUE(m_pTestee->native() == "aa/aaa");
}
-TEST_F( PathTest, should_become_generic_string ) {
+TEST_F(PathTest, should_become_generic_string) {
m_pTestee->assign("/etc/../dev/../usr//lib//");
EXPECT_STREQ("/usr/lib/", m_pTestee->generic_string().c_str());
}
-TEST_F( PathTest, parent_path ) {
+TEST_F(PathTest, parent_path) {
m_pTestee->assign("aa/bb/cc/dd");
EXPECT_STREQ("aa/bb/cc", m_pTestee->parent_path().c_str());
delete m_pTestee;
diff --git a/unittests/PathTest.h b/unittests/PathTest.h
index 417a07f..a31b16a 100644
--- a/unittests/PathTest.h
+++ b/unittests/PathTest.h
@@ -12,34 +12,31 @@
#include "mcld/Support/Path.h"
#include <gtest.h>
-namespace mcldtest
-{
+namespace mcldtest {
/** \class PathTest
* \brief a testcase for mcld::Path and its non-member funtions.
*
* \see Path
*/
-class PathTest : public ::testing::Test
-{
-public:
- // Constructor can do set-up work for all test here.
- PathTest();
+class PathTest : public ::testing::Test {
+ public:
+ // Constructor can do set-up work for all test here.
+ PathTest();
- // Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~PathTest();
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~PathTest();
- // SetUp() will be called immediately before each test.
- virtual void SetUp();
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
- // TearDown() will be called immediately after each test.
- virtual void TearDown();
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
-protected:
- mcld::sys::fs::Path* m_pTestee;
+ protected:
+ mcld::sys::fs::Path* m_pTestee;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/RTLinearAllocatorTest.cpp b/unittests/RTLinearAllocatorTest.cpp
index 1e07f4a..1350c50 100644
--- a/unittests/RTLinearAllocatorTest.cpp
+++ b/unittests/RTLinearAllocatorTest.cpp
@@ -6,34 +6,29 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/Support/Allocators.h>
+#include "mcld/Support/Allocators.h"
#include "RTLinearAllocatorTest.h"
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-RTLinearAllocatorTest::RTLinearAllocatorTest()
-{
- // create testee. modify it if need
- m_pTestee = new LinearAllocator<Data, 0>(CHUNK_SIZE);
+RTLinearAllocatorTest::RTLinearAllocatorTest() {
+ // create testee. modify it if need
+ m_pTestee = new LinearAllocator<Data, 0>(CHUNK_SIZE);
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-RTLinearAllocatorTest::~RTLinearAllocatorTest()
-{
- delete m_pTestee;
+RTLinearAllocatorTest::~RTLinearAllocatorTest() {
+ delete m_pTestee;
}
// SetUp() will be called immediately before each test.
-void RTLinearAllocatorTest::SetUp()
-{
+void RTLinearAllocatorTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void RTLinearAllocatorTest::TearDown()
-{
+void RTLinearAllocatorTest::TearDown() {
}
//==========================================================================//
@@ -41,100 +36,99 @@
//
TEST_F(RTLinearAllocatorTest, AllocateN) {
- Data* pointer = m_pTestee->allocate(10);
- ASSERT_FALSE(0 == pointer);
- ASSERT_TRUE(CHUNK_SIZE == m_pTestee->max_size());
- ASSERT_FALSE(m_pTestee->empty());
+ Data* pointer = m_pTestee->allocate(10);
+ ASSERT_FALSE(0 == pointer);
+ ASSERT_TRUE(CHUNK_SIZE == m_pTestee->max_size());
+ ASSERT_FALSE(m_pTestee->empty());
}
-TEST_F(RTLinearAllocatorTest, allocate ) {
- Data* pointer = m_pTestee->allocate();
- ASSERT_FALSE(0 == pointer);
- ASSERT_TRUE(CHUNK_SIZE == m_pTestee->max_size());
- ASSERT_FALSE(m_pTestee->empty());
+TEST_F(RTLinearAllocatorTest, allocate) {
+ Data* pointer = m_pTestee->allocate();
+ ASSERT_FALSE(0 == pointer);
+ ASSERT_TRUE(CHUNK_SIZE == m_pTestee->max_size());
+ ASSERT_FALSE(m_pTestee->empty());
}
-TEST_F(RTLinearAllocatorTest, allocateOver ) {
- Data* pointer = m_pTestee->allocate(CHUNK_SIZE+1);
- ASSERT_TRUE(0 == pointer);
- ASSERT_TRUE(0 == m_pTestee->max_size());
- ASSERT_TRUE(m_pTestee->empty());
+TEST_F(RTLinearAllocatorTest, allocateOver) {
+ Data* pointer = m_pTestee->allocate(CHUNK_SIZE + 1);
+ ASSERT_TRUE(0 == pointer);
+ ASSERT_TRUE(0 == m_pTestee->max_size());
+ ASSERT_TRUE(m_pTestee->empty());
}
-TEST_F(RTLinearAllocatorTest, alloc_construct ) {
- Data* pointer = m_pTestee->allocate();
- m_pTestee->construct(pointer);
- ASSERT_TRUE(1 == pointer->one);
- ASSERT_TRUE(2 == pointer->two);
- ASSERT_TRUE(3 == pointer->three);
- ASSERT_TRUE(4 == pointer->four);
+TEST_F(RTLinearAllocatorTest, alloc_construct) {
+ Data* pointer = m_pTestee->allocate();
+ m_pTestee->construct(pointer);
+ ASSERT_TRUE(1 == pointer->one);
+ ASSERT_TRUE(2 == pointer->two);
+ ASSERT_TRUE(3 == pointer->three);
+ ASSERT_TRUE(4 == pointer->four);
}
-TEST_F(RTLinearAllocatorTest, alloc_constructCopy ) {
- Data* pointer = m_pTestee->allocate();
- Data data(7, 7, 7, 7);
- m_pTestee->construct(pointer, data);
+TEST_F(RTLinearAllocatorTest, alloc_constructCopy) {
+ Data* pointer = m_pTestee->allocate();
+ Data data(7, 7, 7, 7);
+ m_pTestee->construct(pointer, data);
- ASSERT_TRUE(7 == pointer->one);
- ASSERT_TRUE(7 == pointer->two);
- ASSERT_TRUE(7 == pointer->three);
- ASSERT_TRUE(7 == pointer->four);
+ ASSERT_TRUE(7 == pointer->one);
+ ASSERT_TRUE(7 == pointer->two);
+ ASSERT_TRUE(7 == pointer->three);
+ ASSERT_TRUE(7 == pointer->four);
}
-TEST_F(RTLinearAllocatorTest, allocN_construct ) {
- Data* pointer = m_pTestee->allocate(10);
- m_pTestee->construct(pointer);
- ASSERT_TRUE(1 == pointer->one);
- ASSERT_TRUE(2 == pointer->two);
- ASSERT_TRUE(3 == pointer->three);
- ASSERT_TRUE(4 == pointer->four);
+TEST_F(RTLinearAllocatorTest, allocN_construct) {
+ Data* pointer = m_pTestee->allocate(10);
+ m_pTestee->construct(pointer);
+ ASSERT_TRUE(1 == pointer->one);
+ ASSERT_TRUE(2 == pointer->two);
+ ASSERT_TRUE(3 == pointer->three);
+ ASSERT_TRUE(4 == pointer->four);
}
-TEST_F(RTLinearAllocatorTest, allocN_constructCopy ) {
- Data* pointer = m_pTestee->allocate(10);
- Data data(7, 7, 7, 7);
- m_pTestee->construct(pointer, data);
-
- ASSERT_TRUE(7 == pointer->one);
- ASSERT_TRUE(7 == pointer->two);
- ASSERT_TRUE(7 == pointer->three);
- ASSERT_TRUE(7 == pointer->four);
+TEST_F(RTLinearAllocatorTest, allocN_constructCopy) {
+ Data* pointer = m_pTestee->allocate(10);
+ Data data(7, 7, 7, 7);
+ m_pTestee->construct(pointer, data);
+
+ ASSERT_TRUE(7 == pointer->one);
+ ASSERT_TRUE(7 == pointer->two);
+ ASSERT_TRUE(7 == pointer->three);
+ ASSERT_TRUE(7 == pointer->four);
}
-TEST_F(RTLinearAllocatorTest, multi_alloc_ctor_iterate ) {
- for (int i=0; i<101; ++i) {
- Data* pointer = m_pTestee->allocate();
- m_pTestee->construct(pointer);
- pointer->one = i;
- }
-/**
- Alloc::iterator data, dEnd = m_pTestee->end();
- int counter = 0;
- for (data=m_pTestee->begin(); data!=dEnd; ++data) {
- ASSERT_EQ(counter, (*data).one);
- ++counter;
- }
-**/
+TEST_F(RTLinearAllocatorTest, multi_alloc_ctor_iterate) {
+ for (int i = 0; i < 101; ++i) {
+ Data* pointer = m_pTestee->allocate();
+ m_pTestee->construct(pointer);
+ pointer->one = i;
+ }
+ /**
+ Alloc::iterator data, dEnd = m_pTestee->end();
+ int counter = 0;
+ for (data=m_pTestee->begin(); data!=dEnd; ++data) {
+ ASSERT_EQ(counter, (*data).one);
+ ++counter;
+ }
+ **/
}
-TEST_F(RTLinearAllocatorTest, multi_allocN_ctor_iterate ) {
- int counter = 0;
- for (int i=0; i<10000; ++i) {
- Data* pointer = m_pTestee->allocate(10);
- for (int j=0; j<10; ++j) {
- m_pTestee->construct(pointer);
- pointer->one = counter;
- ++pointer;
- ++counter;
- }
- }
-/**
- Alloc::iterator data, dEnd = m_pTestee->end();
- counter = 0;
- for (data=m_pTestee->begin(); data!=dEnd; ++data) {
- ASSERT_EQ(counter, (*data).one);
- ++counter;
- }
-**/
+TEST_F(RTLinearAllocatorTest, multi_allocN_ctor_iterate) {
+ int counter = 0;
+ for (int i = 0; i < 10000; ++i) {
+ Data* pointer = m_pTestee->allocate(10);
+ for (int j = 0; j < 10; ++j) {
+ m_pTestee->construct(pointer);
+ pointer->one = counter;
+ ++pointer;
+ ++counter;
+ }
+ }
+ /**
+ Alloc::iterator data, dEnd = m_pTestee->end();
+ counter = 0;
+ for (data=m_pTestee->begin(); data!=dEnd; ++data) {
+ ASSERT_EQ(counter, (*data).one);
+ ++counter;
+ }
+ **/
}
-
diff --git a/unittests/RTLinearAllocatorTest.h b/unittests/RTLinearAllocatorTest.h
index 3ba0cd9..2c4a732 100644
--- a/unittests/RTLinearAllocatorTest.h
+++ b/unittests/RTLinearAllocatorTest.h
@@ -12,63 +12,59 @@
#include <gtest.h>
#include "mcld/Support/Allocators.h"
-namespace mcldtest
-{
+namespace mcldtest {
/** \class RTLinearAllocatorTest
* \brief
*
* \see RTLinearAllocator
*/
-class RTLinearAllocatorTest : public ::testing::Test
-{
-public:
- // Constructor can do set-up work for all test here.
- RTLinearAllocatorTest();
+class RTLinearAllocatorTest : public ::testing::Test {
+ public:
+ // Constructor can do set-up work for all test here.
+ RTLinearAllocatorTest();
- // Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~RTLinearAllocatorTest();
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~RTLinearAllocatorTest();
- // SetUp() will be called immediately before each test.
- virtual void SetUp();
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
- // TearDown() will be called immediately after each test.
- virtual void TearDown();
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
-public:
- struct Data {
- Data()
- : one(1), two(2), three(3), four(4)
- { }
+ public:
+ struct Data {
+ Data() : one(1), two(2), three(3), four(4) {}
- Data( unsigned int pOne, unsigned int pTwo, unsigned char pThree, unsigned char pFour)
- {
- one = pOne;
- two = pTwo;
- three = pThree;
- four = pFour;
- }
+ Data(unsigned int pOne,
+ unsigned int pTwo,
+ unsigned char pThree,
+ unsigned char pFour) {
+ one = pOne;
+ two = pTwo;
+ three = pThree;
+ four = pFour;
+ }
- ~Data()
- {
- one = -1;
- two = -2;
- three = -3;
- four = -4;
- }
+ ~Data() {
+ one = -1;
+ two = -2;
+ three = -3;
+ four = -4;
+ }
- unsigned int one;
- unsigned int two;
- unsigned char three;
- unsigned char four;
+ unsigned int one;
+ unsigned int two;
+ unsigned char three;
+ unsigned char four;
};
- enum { CHUNK_SIZE = 32 };
+ enum { CHUNK_SIZE = 32 };
-protected:
- mcld::LinearAllocator<Data,0>* m_pTestee;
+ protected:
+ mcld::LinearAllocator<Data, 0>* m_pTestee;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/SectionDataTest.cpp b/unittests/SectionDataTest.cpp
index 6a7e366..e9a9292 100644
--- a/unittests/SectionDataTest.cpp
+++ b/unittests/SectionDataTest.cpp
@@ -8,50 +8,44 @@
//===----------------------------------------------------------------------===//
#include "SectionDataTest.h"
-#include <mcld/LD/SectionData.h>
-#include <mcld/LD/LDFileFormat.h>
-#include <mcld/LD/LDSection.h>
+#include "mcld/LD/SectionData.h"
+#include "mcld/LD/LDFileFormat.h"
+#include "mcld/LD/LDSection.h"
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-SectionDataTest::SectionDataTest()
-{
+SectionDataTest::SectionDataTest() {
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-SectionDataTest::~SectionDataTest()
-{
+SectionDataTest::~SectionDataTest() {
}
// SetUp() will be called immediately before each test.
-void SectionDataTest::SetUp()
-{
+void SectionDataTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void SectionDataTest::TearDown()
-{
+void SectionDataTest::TearDown() {
}
//===----------------------------------------------------------------------===//
// Testcases
//===----------------------------------------------------------------------===//
-TEST_F( SectionDataTest, constructor_and_trivial_func ) {
+TEST_F(SectionDataTest, constructor_and_trivial_func) {
LDSection* test = LDSection::Create("test", LDFileFormat::Null, 0, 0);
SectionData* s = SectionData::Create(*test);
- EXPECT_TRUE(s->getSection().name() == "test" && \
+ EXPECT_TRUE(s->getSection().name() == "test" &&
s->getSection().kind() == LDFileFormat::Null);
-
LDSection::Destroy(test);
}
-TEST_F( SectionDataTest, Fragment_list_and_iterator ) {
+TEST_F(SectionDataTest, Fragment_list_and_iterator) {
LDSection* test = LDSection::Create("test", LDFileFormat::Null, 0, 0);
SectionData* s = SectionData::Create(*test);
EXPECT_TRUE(s->empty());
@@ -63,8 +57,8 @@
new Fragment(Fragment::Target, s);
EXPECT_TRUE(5 == s->size());
- //iterator
- llvm::iplist<Fragment>::iterator iter=s->begin();
+ // iterator
+ llvm::iplist<Fragment>::iterator iter = s->begin();
EXPECT_TRUE(Fragment::Alignment == iter->getKind());
++iter;
EXPECT_TRUE(Fragment::Alignment == iter->getKind());
diff --git a/unittests/SectionDataTest.h b/unittests/SectionDataTest.h
index bbc2736..6717f5e 100644
--- a/unittests/SectionDataTest.h
+++ b/unittests/SectionDataTest.h
@@ -13,14 +13,12 @@
namespace mcld {
class SectionData;
-} // namespace for mcld
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
-class SectionDataTest : public ::testing::Test
-{
-public:
+class SectionDataTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
SectionDataTest();
@@ -34,7 +32,6 @@
virtual void TearDown();
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/StaticResolverTest.cpp b/unittests/StaticResolverTest.cpp
index a474cdd..75fb34c 100644
--- a/unittests/StaticResolverTest.cpp
+++ b/unittests/StaticResolverTest.cpp
@@ -7,12 +7,12 @@
//
//===----------------------------------------------------------------------===//
#include "StaticResolverTest.h"
-#include <mcld/Support/TargetSelect.h>
-#include <mcld/LD/StaticResolver.h>
-#include <mcld/LD/ResolveInfo.h>
-#include <mcld/LinkerConfig.h>
+#include "mcld/Support/TargetSelect.h"
+#include "mcld/LD/StaticResolver.h"
+#include "mcld/LD/ResolveInfo.h"
+#include "mcld/LinkerConfig.h"
-#include <mcld/Support/FileSystem.h>
+#include "mcld/Support/FileSystem.h"
using namespace mcld;
using namespace mcldtest;
@@ -21,8 +21,7 @@
// StaticResolverTest
//===----------------------------------------------------------------------===//
// Constructor can do set-up work for all test here.
-StaticResolverTest::StaticResolverTest()
- : m_pResolver(NULL), m_pConfig(NULL) {
+StaticResolverTest::StaticResolverTest() : m_pResolver(NULL), m_pConfig(NULL) {
// create testee. modify it if need
m_pResolver = new StaticResolver();
@@ -30,41 +29,38 @@
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-StaticResolverTest::~StaticResolverTest()
-{
+StaticResolverTest::~StaticResolverTest() {
delete m_pResolver;
delete m_pConfig;
}
// SetUp() will be called immediately before each test.
-void StaticResolverTest::SetUp()
-{
+void StaticResolverTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void StaticResolverTest::TearDown()
-{
+void StaticResolverTest::TearDown() {
}
//==========================================================================//
// Testcases
//
-TEST_F( StaticResolverTest, MDEF ) {
+TEST_F(StaticResolverTest, MDEF) {
ResolveInfo* old_sym = ResolveInfo::Create("abc");
ResolveInfo* new_sym = ResolveInfo::Create("abc");
new_sym->setDesc(ResolveInfo::Define);
old_sym->setDesc(ResolveInfo::Define);
- ASSERT_TRUE( mcld::ResolveInfo::Define == new_sym->desc());
- ASSERT_TRUE( mcld::ResolveInfo::Define == old_sym->desc());
- ASSERT_TRUE( mcld::ResolveInfo::define_flag == new_sym->info());
- ASSERT_TRUE( mcld::ResolveInfo::define_flag == old_sym->info());
+ ASSERT_TRUE(mcld::ResolveInfo::Define == new_sym->desc());
+ ASSERT_TRUE(mcld::ResolveInfo::Define == old_sym->desc());
+ ASSERT_TRUE(mcld::ResolveInfo::define_flag == new_sym->info());
+ ASSERT_TRUE(mcld::ResolveInfo::define_flag == old_sym->info());
bool override = true;
bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
ASSERT_TRUE(result);
- ASSERT_FALSE( override );
+ ASSERT_FALSE(override);
}
-TEST_F( StaticResolverTest, DynDefAfterDynUndef ) {
+TEST_F(StaticResolverTest, DynDefAfterDynUndef) {
ResolveInfo* old_sym = ResolveInfo::Create("abc");
ResolveInfo* new_sym = ResolveInfo::Create("abc");
@@ -79,19 +75,19 @@
old_sym->setSize(1);
- ASSERT_TRUE( mcld::ResolveInfo::Global == new_sym->binding());
- ASSERT_TRUE( mcld::ResolveInfo::Global == old_sym->binding());
- ASSERT_TRUE( mcld::ResolveInfo::Undefined == new_sym->desc());
- ASSERT_TRUE( mcld::ResolveInfo::Define == old_sym->desc());
+ ASSERT_TRUE(mcld::ResolveInfo::Global == new_sym->binding());
+ ASSERT_TRUE(mcld::ResolveInfo::Global == old_sym->binding());
+ ASSERT_TRUE(mcld::ResolveInfo::Undefined == new_sym->desc());
+ ASSERT_TRUE(mcld::ResolveInfo::Define == old_sym->desc());
bool override = false;
bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
ASSERT_TRUE(result);
- ASSERT_FALSE( override );
+ ASSERT_FALSE(override);
ASSERT_TRUE(1 == old_sym->size());
}
-TEST_F( StaticResolverTest, DynDefAfterDynDef ) {
+TEST_F(StaticResolverTest, DynDefAfterDynDef) {
ResolveInfo* old_sym = ResolveInfo::Create("abc");
ResolveInfo* new_sym = ResolveInfo::Create("abc");
@@ -106,19 +102,19 @@
old_sym->setSize(1);
- ASSERT_TRUE( mcld::ResolveInfo::Global == new_sym->binding());
- ASSERT_TRUE( mcld::ResolveInfo::Global == old_sym->binding());
- ASSERT_TRUE( mcld::ResolveInfo::Define == new_sym->desc());
- ASSERT_TRUE( mcld::ResolveInfo::Define == old_sym->desc());
+ ASSERT_TRUE(mcld::ResolveInfo::Global == new_sym->binding());
+ ASSERT_TRUE(mcld::ResolveInfo::Global == old_sym->binding());
+ ASSERT_TRUE(mcld::ResolveInfo::Define == new_sym->desc());
+ ASSERT_TRUE(mcld::ResolveInfo::Define == old_sym->desc());
bool override = false;
bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
ASSERT_TRUE(result);
- ASSERT_FALSE( override );
+ ASSERT_FALSE(override);
ASSERT_TRUE(1 == old_sym->size());
}
-TEST_F( StaticResolverTest, DynUndefAfterDynUndef ) {
+TEST_F(StaticResolverTest, DynUndefAfterDynUndef) {
ResolveInfo* old_sym = ResolveInfo::Create("abc");
ResolveInfo* new_sym = ResolveInfo::Create("abc");
@@ -133,20 +129,19 @@
old_sym->setSize(1);
- ASSERT_TRUE( mcld::ResolveInfo::Global == new_sym->binding());
- ASSERT_TRUE( mcld::ResolveInfo::Global == old_sym->binding());
- ASSERT_TRUE( mcld::ResolveInfo::Undefined == new_sym->desc());
- ASSERT_TRUE( mcld::ResolveInfo::Undefined == old_sym->desc());
+ ASSERT_TRUE(mcld::ResolveInfo::Global == new_sym->binding());
+ ASSERT_TRUE(mcld::ResolveInfo::Global == old_sym->binding());
+ ASSERT_TRUE(mcld::ResolveInfo::Undefined == new_sym->desc());
+ ASSERT_TRUE(mcld::ResolveInfo::Undefined == old_sym->desc());
bool override = false;
bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
ASSERT_TRUE(result);
- ASSERT_FALSE( override );
+ ASSERT_FALSE(override);
ASSERT_TRUE(1 == old_sym->size());
}
-TEST_F( StaticResolverTest, OverrideWeakByGlobal )
-{
+TEST_F(StaticResolverTest, OverrideWeakByGlobal) {
ResolveInfo* old_sym = ResolveInfo::Create("abc");
ResolveInfo* new_sym = ResolveInfo::Create("abc");
@@ -155,19 +150,19 @@
new_sym->setSize(0);
old_sym->setSize(1);
- ASSERT_TRUE( mcld::ResolveInfo::Global == new_sym->binding());
- ASSERT_TRUE( mcld::ResolveInfo::Weak == old_sym->binding());
+ ASSERT_TRUE(mcld::ResolveInfo::Global == new_sym->binding());
+ ASSERT_TRUE(mcld::ResolveInfo::Weak == old_sym->binding());
- ASSERT_TRUE( mcld::ResolveInfo::global_flag == new_sym->info());
- ASSERT_TRUE( mcld::ResolveInfo::weak_flag == old_sym->info());
+ ASSERT_TRUE(mcld::ResolveInfo::global_flag == new_sym->info());
+ ASSERT_TRUE(mcld::ResolveInfo::weak_flag == old_sym->info());
bool override = false;
bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
ASSERT_TRUE(result);
- ASSERT_TRUE( override );
+ ASSERT_TRUE(override);
ASSERT_TRUE(0 == old_sym->size());
}
-TEST_F( StaticResolverTest, DynWeakAfterDynDef ) {
+TEST_F(StaticResolverTest, DynWeakAfterDynDef) {
ResolveInfo* old_sym = ResolveInfo::Create("abc");
ResolveInfo* new_sym = ResolveInfo::Create("abc");
@@ -184,20 +179,19 @@
old_sym->setSize(1);
- ASSERT_TRUE( mcld::ResolveInfo::Weak == old_sym->binding());
- ASSERT_TRUE( mcld::ResolveInfo::Global == new_sym->binding());
- ASSERT_TRUE( mcld::ResolveInfo::Define == old_sym->desc());
- ASSERT_TRUE( mcld::ResolveInfo::Define == new_sym->desc());
+ ASSERT_TRUE(mcld::ResolveInfo::Weak == old_sym->binding());
+ ASSERT_TRUE(mcld::ResolveInfo::Global == new_sym->binding());
+ ASSERT_TRUE(mcld::ResolveInfo::Define == old_sym->desc());
+ ASSERT_TRUE(mcld::ResolveInfo::Define == new_sym->desc());
bool override = false;
bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
ASSERT_TRUE(result);
- ASSERT_FALSE( override );
+ ASSERT_FALSE(override);
ASSERT_TRUE(1 == old_sym->size());
}
-TEST_F( StaticResolverTest, MarkByBiggerCommon )
-{
+TEST_F(StaticResolverTest, MarkByBiggerCommon) {
ResolveInfo* old_sym = ResolveInfo::Create("abc");
ResolveInfo* new_sym = ResolveInfo::Create("abc");
@@ -206,20 +200,19 @@
new_sym->setSize(999);
old_sym->setSize(0);
- ASSERT_TRUE( mcld::ResolveInfo::Common == new_sym->desc());
- ASSERT_TRUE( mcld::ResolveInfo::Common == old_sym->desc());
+ ASSERT_TRUE(mcld::ResolveInfo::Common == new_sym->desc());
+ ASSERT_TRUE(mcld::ResolveInfo::Common == old_sym->desc());
- ASSERT_TRUE( mcld::ResolveInfo::common_flag == new_sym->info());
- ASSERT_TRUE( mcld::ResolveInfo::common_flag == old_sym->info());
+ ASSERT_TRUE(mcld::ResolveInfo::common_flag == new_sym->info());
+ ASSERT_TRUE(mcld::ResolveInfo::common_flag == old_sym->info());
bool override = true;
bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
ASSERT_TRUE(result);
- ASSERT_FALSE( override );
+ ASSERT_FALSE(override);
ASSERT_TRUE(999 == old_sym->size());
}
-TEST_F( StaticResolverTest, OverrideByBiggerCommon )
-{
+TEST_F(StaticResolverTest, OverrideByBiggerCommon) {
ResolveInfo* old_sym = ResolveInfo::Create("abc");
ResolveInfo* new_sym = ResolveInfo::Create("abc");
@@ -229,22 +222,22 @@
new_sym->setSize(999);
old_sym->setSize(0);
- ASSERT_TRUE( ResolveInfo::Common == new_sym->desc());
- ASSERT_TRUE( ResolveInfo::Common == old_sym->desc());
- ASSERT_TRUE( ResolveInfo::Weak == old_sym->binding());
+ ASSERT_TRUE(ResolveInfo::Common == new_sym->desc());
+ ASSERT_TRUE(ResolveInfo::Common == old_sym->desc());
+ ASSERT_TRUE(ResolveInfo::Weak == old_sym->binding());
- ASSERT_TRUE( ResolveInfo::common_flag == new_sym->info());
- ASSERT_TRUE( (ResolveInfo::weak_flag | ResolveInfo::common_flag) == old_sym->info());
+ ASSERT_TRUE(ResolveInfo::common_flag == new_sym->info());
+ ASSERT_TRUE((ResolveInfo::weak_flag | ResolveInfo::common_flag) ==
+ old_sym->info());
bool override = false;
bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
ASSERT_TRUE(result);
- ASSERT_TRUE( override );
+ ASSERT_TRUE(override);
ASSERT_TRUE(999 == old_sym->size());
}
-TEST_F( StaticResolverTest, OverrideCommonByDefine)
-{
+TEST_F(StaticResolverTest, OverrideCommonByDefine) {
ResolveInfo* old_sym = ResolveInfo::Create("abc");
ResolveInfo* new_sym = ResolveInfo::Create("abc");
@@ -254,183 +247,180 @@
new_sym->setDesc(ResolveInfo::Define);
new_sym->setSize(999);
- ASSERT_TRUE( ResolveInfo::Define == new_sym->desc());
- ASSERT_TRUE( ResolveInfo::Common == old_sym->desc());
+ ASSERT_TRUE(ResolveInfo::Define == new_sym->desc());
+ ASSERT_TRUE(ResolveInfo::Common == old_sym->desc());
- ASSERT_TRUE( ResolveInfo::define_flag == new_sym->info());
- ASSERT_TRUE( ResolveInfo::common_flag == old_sym->info());
+ ASSERT_TRUE(ResolveInfo::define_flag == new_sym->info());
+ ASSERT_TRUE(ResolveInfo::common_flag == old_sym->info());
bool override = false;
bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
ASSERT_TRUE(result);
- ASSERT_TRUE( override );
+ ASSERT_TRUE(override);
ASSERT_TRUE(999 == old_sym->size());
}
-TEST_F( StaticResolverTest, SetUpDesc)
-{
+TEST_F(StaticResolverTest, SetUpDesc) {
ResolveInfo* sym = ResolveInfo::Create("abc");
sym->setIsSymbol(true);
-// ASSERT_FALSE( sym->isSymbol() );
- ASSERT_TRUE( sym->isSymbol() );
- ASSERT_TRUE( sym->isGlobal() );
- ASSERT_FALSE( sym->isWeak() );
- ASSERT_FALSE( sym->isLocal() );
- ASSERT_FALSE( sym->isDefine() );
- ASSERT_TRUE( sym->isUndef() );
- ASSERT_FALSE( sym->isDyn() );
- ASSERT_FALSE( sym->isCommon() );
- ASSERT_FALSE( sym->isIndirect() );
- ASSERT_TRUE( ResolveInfo::NoType == sym->type());
- ASSERT_TRUE( 0 == sym->desc() );
- ASSERT_TRUE( 0 == sym->binding() );
- ASSERT_TRUE( 0 == sym->other() );
+ // ASSERT_FALSE( sym->isSymbol() );
+ ASSERT_TRUE(sym->isSymbol());
+ ASSERT_TRUE(sym->isGlobal());
+ ASSERT_FALSE(sym->isWeak());
+ ASSERT_FALSE(sym->isLocal());
+ ASSERT_FALSE(sym->isDefine());
+ ASSERT_TRUE(sym->isUndef());
+ ASSERT_FALSE(sym->isDyn());
+ ASSERT_FALSE(sym->isCommon());
+ ASSERT_FALSE(sym->isIndirect());
+ ASSERT_TRUE(ResolveInfo::NoType == sym->type());
+ ASSERT_TRUE(0 == sym->desc());
+ ASSERT_TRUE(0 == sym->binding());
+ ASSERT_TRUE(0 == sym->other());
sym->setIsSymbol(false);
- ASSERT_FALSE( sym->isSymbol() );
-// ASSERT_TRUE( sym->isSymbol() );
- ASSERT_TRUE( sym->isGlobal() );
- ASSERT_FALSE( sym->isWeak() );
- ASSERT_FALSE( sym->isLocal() );
- ASSERT_FALSE( sym->isDefine() );
- ASSERT_TRUE( sym->isUndef() );
- ASSERT_FALSE( sym->isDyn() );
- ASSERT_FALSE( sym->isCommon() );
- ASSERT_FALSE( sym->isIndirect() );
- ASSERT_TRUE( ResolveInfo::NoType == sym->type());
- ASSERT_TRUE( 0 == sym->desc() );
- ASSERT_TRUE( 0 == sym->binding() );
- ASSERT_TRUE( 0 == sym->other() );
+ ASSERT_FALSE(sym->isSymbol());
+ // ASSERT_TRUE( sym->isSymbol() );
+ ASSERT_TRUE(sym->isGlobal());
+ ASSERT_FALSE(sym->isWeak());
+ ASSERT_FALSE(sym->isLocal());
+ ASSERT_FALSE(sym->isDefine());
+ ASSERT_TRUE(sym->isUndef());
+ ASSERT_FALSE(sym->isDyn());
+ ASSERT_FALSE(sym->isCommon());
+ ASSERT_FALSE(sym->isIndirect());
+ ASSERT_TRUE(ResolveInfo::NoType == sym->type());
+ ASSERT_TRUE(0 == sym->desc());
+ ASSERT_TRUE(0 == sym->binding());
+ ASSERT_TRUE(0 == sym->other());
sym->setDesc(ResolveInfo::Define);
- ASSERT_FALSE( sym->isSymbol() );
-// ASSERT_TRUE( sym->isSymbol() );
- ASSERT_TRUE( sym->isGlobal() );
- ASSERT_FALSE( sym->isWeak() );
- ASSERT_FALSE( sym->isLocal() );
- ASSERT_TRUE( sym->isDefine() );
- ASSERT_FALSE( sym->isUndef() );
- ASSERT_FALSE( sym->isDyn() );
- ASSERT_FALSE( sym->isCommon() );
- ASSERT_FALSE( sym->isIndirect() );
- ASSERT_TRUE( ResolveInfo::NoType == sym->type());
- ASSERT_TRUE( ResolveInfo::Define == sym->desc() );
- ASSERT_TRUE( 0 == sym->binding() );
- ASSERT_TRUE( 0 == sym->other() );
+ ASSERT_FALSE(sym->isSymbol());
+ // ASSERT_TRUE( sym->isSymbol() );
+ ASSERT_TRUE(sym->isGlobal());
+ ASSERT_FALSE(sym->isWeak());
+ ASSERT_FALSE(sym->isLocal());
+ ASSERT_TRUE(sym->isDefine());
+ ASSERT_FALSE(sym->isUndef());
+ ASSERT_FALSE(sym->isDyn());
+ ASSERT_FALSE(sym->isCommon());
+ ASSERT_FALSE(sym->isIndirect());
+ ASSERT_TRUE(ResolveInfo::NoType == sym->type());
+ ASSERT_TRUE(ResolveInfo::Define == sym->desc());
+ ASSERT_TRUE(0 == sym->binding());
+ ASSERT_TRUE(0 == sym->other());
sym->setDesc(ResolveInfo::Common);
- ASSERT_FALSE( sym->isSymbol() );
-// ASSERT_TRUE( sym->isSymbol() );
- ASSERT_TRUE( sym->isGlobal() );
- ASSERT_FALSE( sym->isWeak() );
- ASSERT_FALSE( sym->isLocal() );
- ASSERT_FALSE( sym->isDyn() );
- ASSERT_FALSE( sym->isDefine() );
- ASSERT_FALSE( sym->isUndef() );
- ASSERT_TRUE( sym->isCommon() );
- ASSERT_FALSE( sym->isIndirect() );
- ASSERT_TRUE( ResolveInfo::NoType == sym->type());
- ASSERT_TRUE( ResolveInfo::Common == sym->desc() );
- ASSERT_TRUE( 0 == sym->binding() );
- ASSERT_TRUE( 0 == sym->other() );
+ ASSERT_FALSE(sym->isSymbol());
+ // ASSERT_TRUE( sym->isSymbol() );
+ ASSERT_TRUE(sym->isGlobal());
+ ASSERT_FALSE(sym->isWeak());
+ ASSERT_FALSE(sym->isLocal());
+ ASSERT_FALSE(sym->isDyn());
+ ASSERT_FALSE(sym->isDefine());
+ ASSERT_FALSE(sym->isUndef());
+ ASSERT_TRUE(sym->isCommon());
+ ASSERT_FALSE(sym->isIndirect());
+ ASSERT_TRUE(ResolveInfo::NoType == sym->type());
+ ASSERT_TRUE(ResolveInfo::Common == sym->desc());
+ ASSERT_TRUE(0 == sym->binding());
+ ASSERT_TRUE(0 == sym->other());
sym->setDesc(ResolveInfo::Indirect);
- ASSERT_FALSE( sym->isSymbol() );
- ASSERT_TRUE( sym->isGlobal() );
- ASSERT_FALSE( sym->isWeak() );
- ASSERT_FALSE( sym->isLocal() );
- ASSERT_FALSE( sym->isDyn() );
- ASSERT_FALSE( sym->isDefine() );
- ASSERT_FALSE( sym->isUndef() );
- ASSERT_FALSE( sym->isCommon() );
- ASSERT_TRUE( sym->isIndirect() );
- ASSERT_TRUE( ResolveInfo::NoType == sym->type());
- ASSERT_TRUE( ResolveInfo::Indirect == sym->desc() );
- ASSERT_TRUE( 0 == sym->binding() );
- ASSERT_TRUE( 0 == sym->other() );
+ ASSERT_FALSE(sym->isSymbol());
+ ASSERT_TRUE(sym->isGlobal());
+ ASSERT_FALSE(sym->isWeak());
+ ASSERT_FALSE(sym->isLocal());
+ ASSERT_FALSE(sym->isDyn());
+ ASSERT_FALSE(sym->isDefine());
+ ASSERT_FALSE(sym->isUndef());
+ ASSERT_FALSE(sym->isCommon());
+ ASSERT_TRUE(sym->isIndirect());
+ ASSERT_TRUE(ResolveInfo::NoType == sym->type());
+ ASSERT_TRUE(ResolveInfo::Indirect == sym->desc());
+ ASSERT_TRUE(0 == sym->binding());
+ ASSERT_TRUE(0 == sym->other());
sym->setDesc(ResolveInfo::Undefined);
- ASSERT_FALSE( sym->isSymbol() );
- ASSERT_TRUE( sym->isGlobal() );
- ASSERT_FALSE( sym->isWeak() );
- ASSERT_FALSE( sym->isLocal() );
- ASSERT_FALSE( sym->isDyn() );
- ASSERT_TRUE( sym->isUndef() );
- ASSERT_FALSE( sym->isDefine() );
- ASSERT_FALSE( sym->isCommon() );
- ASSERT_FALSE( sym->isIndirect() );
- ASSERT_TRUE( ResolveInfo::NoType == sym->type());
- ASSERT_TRUE( 0 == sym->desc() );
- ASSERT_TRUE( 0 == sym->binding() );
- ASSERT_TRUE( 0 == sym->other() );
+ ASSERT_FALSE(sym->isSymbol());
+ ASSERT_TRUE(sym->isGlobal());
+ ASSERT_FALSE(sym->isWeak());
+ ASSERT_FALSE(sym->isLocal());
+ ASSERT_FALSE(sym->isDyn());
+ ASSERT_TRUE(sym->isUndef());
+ ASSERT_FALSE(sym->isDefine());
+ ASSERT_FALSE(sym->isCommon());
+ ASSERT_FALSE(sym->isIndirect());
+ ASSERT_TRUE(ResolveInfo::NoType == sym->type());
+ ASSERT_TRUE(0 == sym->desc());
+ ASSERT_TRUE(0 == sym->binding());
+ ASSERT_TRUE(0 == sym->other());
}
-TEST_F( StaticResolverTest, SetUpBinding)
-{
+TEST_F(StaticResolverTest, SetUpBinding) {
ResolveInfo* sym = ResolveInfo::Create("abc");
sym->setIsSymbol(true);
-// ASSERT_FALSE( sym->isSymbol() );
- ASSERT_TRUE( sym->isSymbol() );
- ASSERT_TRUE( sym->isGlobal() );
- ASSERT_FALSE( sym->isWeak() );
- ASSERT_FALSE( sym->isLocal() );
- ASSERT_FALSE( sym->isDefine() );
- ASSERT_TRUE( sym->isUndef() );
- ASSERT_FALSE( sym->isDyn() );
- ASSERT_FALSE( sym->isCommon() );
- ASSERT_FALSE( sym->isIndirect() );
- ASSERT_TRUE( ResolveInfo::NoType == sym->type());
- ASSERT_TRUE( 0 == sym->desc() );
- ASSERT_TRUE( 0 == sym->binding() );
- ASSERT_TRUE( 0 == sym->other() );
+ // ASSERT_FALSE( sym->isSymbol() );
+ ASSERT_TRUE(sym->isSymbol());
+ ASSERT_TRUE(sym->isGlobal());
+ ASSERT_FALSE(sym->isWeak());
+ ASSERT_FALSE(sym->isLocal());
+ ASSERT_FALSE(sym->isDefine());
+ ASSERT_TRUE(sym->isUndef());
+ ASSERT_FALSE(sym->isDyn());
+ ASSERT_FALSE(sym->isCommon());
+ ASSERT_FALSE(sym->isIndirect());
+ ASSERT_TRUE(ResolveInfo::NoType == sym->type());
+ ASSERT_TRUE(0 == sym->desc());
+ ASSERT_TRUE(0 == sym->binding());
+ ASSERT_TRUE(0 == sym->other());
sym->setBinding(ResolveInfo::Global);
- ASSERT_TRUE( sym->isSymbol() );
- ASSERT_TRUE( sym->isGlobal() );
- ASSERT_FALSE( sym->isWeak() );
- ASSERT_FALSE( sym->isLocal() );
- ASSERT_FALSE( sym->isDefine() );
- ASSERT_TRUE( sym->isUndef() );
- ASSERT_FALSE( sym->isDyn() );
- ASSERT_FALSE( sym->isCommon() );
- ASSERT_FALSE( sym->isIndirect() );
- ASSERT_TRUE( ResolveInfo::NoType == sym->type());
- ASSERT_TRUE( 0 == sym->desc() );
- ASSERT_TRUE( ResolveInfo::Global == sym->binding() );
- ASSERT_TRUE( 0 == sym->other() );
+ ASSERT_TRUE(sym->isSymbol());
+ ASSERT_TRUE(sym->isGlobal());
+ ASSERT_FALSE(sym->isWeak());
+ ASSERT_FALSE(sym->isLocal());
+ ASSERT_FALSE(sym->isDefine());
+ ASSERT_TRUE(sym->isUndef());
+ ASSERT_FALSE(sym->isDyn());
+ ASSERT_FALSE(sym->isCommon());
+ ASSERT_FALSE(sym->isIndirect());
+ ASSERT_TRUE(ResolveInfo::NoType == sym->type());
+ ASSERT_TRUE(0 == sym->desc());
+ ASSERT_TRUE(ResolveInfo::Global == sym->binding());
+ ASSERT_TRUE(0 == sym->other());
sym->setBinding(ResolveInfo::Weak);
- ASSERT_TRUE( sym->isSymbol() );
- ASSERT_FALSE( sym->isGlobal() );
- ASSERT_TRUE( sym->isWeak() );
- ASSERT_FALSE( sym->isLocal() );
- ASSERT_FALSE( sym->isDyn() );
- ASSERT_FALSE( sym->isDefine() );
- ASSERT_TRUE( sym->isUndef() );
- ASSERT_FALSE( sym->isCommon() );
- ASSERT_FALSE( sym->isIndirect() );
- ASSERT_TRUE( ResolveInfo::NoType == sym->type());
- ASSERT_TRUE( 0 == sym->desc() );
- ASSERT_TRUE( ResolveInfo::Weak == sym->binding() );
- ASSERT_TRUE( 0 == sym->other() );
+ ASSERT_TRUE(sym->isSymbol());
+ ASSERT_FALSE(sym->isGlobal());
+ ASSERT_TRUE(sym->isWeak());
+ ASSERT_FALSE(sym->isLocal());
+ ASSERT_FALSE(sym->isDyn());
+ ASSERT_FALSE(sym->isDefine());
+ ASSERT_TRUE(sym->isUndef());
+ ASSERT_FALSE(sym->isCommon());
+ ASSERT_FALSE(sym->isIndirect());
+ ASSERT_TRUE(ResolveInfo::NoType == sym->type());
+ ASSERT_TRUE(0 == sym->desc());
+ ASSERT_TRUE(ResolveInfo::Weak == sym->binding());
+ ASSERT_TRUE(0 == sym->other());
sym->setBinding(ResolveInfo::Local);
- ASSERT_TRUE( sym->isSymbol() );
- ASSERT_FALSE( sym->isGlobal() );
- ASSERT_FALSE( sym->isWeak() );
- ASSERT_TRUE( sym->isLocal() );
- ASSERT_FALSE( sym->isDyn() );
- ASSERT_FALSE( sym->isDefine() );
- ASSERT_TRUE( sym->isUndef() );
- ASSERT_FALSE( sym->isCommon() );
- ASSERT_FALSE( sym->isIndirect() );
- ASSERT_TRUE( ResolveInfo::NoType == sym->type());
- ASSERT_TRUE( 0 == sym->desc() );
- ASSERT_TRUE( ResolveInfo::Local == sym->binding() );
- ASSERT_TRUE( 0 == sym->other() );
+ ASSERT_TRUE(sym->isSymbol());
+ ASSERT_FALSE(sym->isGlobal());
+ ASSERT_FALSE(sym->isWeak());
+ ASSERT_TRUE(sym->isLocal());
+ ASSERT_FALSE(sym->isDyn());
+ ASSERT_FALSE(sym->isDefine());
+ ASSERT_TRUE(sym->isUndef());
+ ASSERT_FALSE(sym->isCommon());
+ ASSERT_FALSE(sym->isIndirect());
+ ASSERT_TRUE(ResolveInfo::NoType == sym->type());
+ ASSERT_TRUE(0 == sym->desc());
+ ASSERT_TRUE(ResolveInfo::Local == sym->binding());
+ ASSERT_TRUE(0 == sym->other());
}
-
diff --git a/unittests/StaticResolverTest.h b/unittests/StaticResolverTest.h
index c6f0699..06f5052 100644
--- a/unittests/StaticResolverTest.h
+++ b/unittests/StaticResolverTest.h
@@ -10,7 +10,7 @@
#define STATICRESOLVER_TEST_H
#include <gtest.h>
-#include <mcld/LinkerConfig.h>
+#include "mcld/LinkerConfig.h"
namespace mcld {
@@ -18,19 +18,17 @@
class ResolveInfoFactory;
class DiagnosticPrinter;
-} // namespace for mcld
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
/** \class StaticResolverTest
* \brief The testcases for static resolver
*
* \see StaticResolver
*/
-class StaticResolverTest : public ::testing::Test
-{
-public:
+class StaticResolverTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
StaticResolverTest();
@@ -43,13 +41,12 @@
// TearDown() will be called immediately after each test.
virtual void TearDown();
-protected:
+ protected:
mcld::StaticResolver* m_pResolver;
mcld::LinkerConfig* m_pConfig;
mcld::DiagnosticPrinter* m_pPrinter;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/StringTableTest.cpp b/unittests/StringTableTest.cpp
index 59a8e7b..061068a 100644
--- a/unittests/StringTableTest.cpp
+++ b/unittests/StringTableTest.cpp
@@ -13,10 +13,8 @@
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-StringTableTest::StringTableTest()
-{
+StringTableTest::StringTableTest() {
// create testee. modify it if need
Resolver* R = new Resolver();
StrSymPool* Pool = new StrSymPool(1, 1, *R);
@@ -24,26 +22,23 @@
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-StringTableTest::~StringTableTest()
-{
+StringTableTest::~StringTableTest() {
delete m_pTestee;
}
// SetUp() will be called immediately before each test.
-void StringTableTest::SetUp()
-{
+void StringTableTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void StringTableTest::TearDown()
-{
+void StringTableTest::TearDown() {
}
//==========================================================================//
// Testcases
//
TEST_F(StringTableTest, different_string_size) {
- int size = 127-32;
+ int size = 127 - 32;
for (int i = 32; i < 127; ++i) {
char c[2];
c[0] = i;
diff --git a/unittests/StringTableTest.h b/unittests/StringTableTest.h
index 60d7f00..8c2ae03 100644
--- a/unittests/StringTableTest.h
+++ b/unittests/StringTableTest.h
@@ -11,23 +11,20 @@
#include <gtest.h>
-namespace mcld
-{
+namespace mcld {
class StringTable;
-} // namespace for mcld
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
/** \class StringTableTest
* \brief
*
* \see StringTable
*/
-class StringTableTest : public ::testing::Test
-{
-public:
+class StringTableTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
StringTableTest();
@@ -40,11 +37,10 @@
// TearDown() will be called immediately after each test.
virtual void TearDown();
-protected:
+ protected:
mcld::StringTable* m_pTestee;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/SymbolCategoryTest.cpp b/unittests/SymbolCategoryTest.cpp
index f1de1d7..7eb1988 100644
--- a/unittests/SymbolCategoryTest.cpp
+++ b/unittests/SymbolCategoryTest.cpp
@@ -6,9 +6,9 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/MC/SymbolCategory.h>
-#include <mcld/LD/ResolveInfo.h>
-#include <mcld/LD/LDSymbol.h>
+#include "mcld/MC/SymbolCategory.h"
+#include "mcld/LD/ResolveInfo.h"
+#include "mcld/LD/LDSymbol.h"
#include <iostream>
#include "SymbolCategoryTest.h"
@@ -16,28 +16,23 @@
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-SymbolCategoryTest::SymbolCategoryTest()
-{
+SymbolCategoryTest::SymbolCategoryTest() {
// create testee. modify it if need
m_pTestee = new SymbolCategory();
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-SymbolCategoryTest::~SymbolCategoryTest()
-{
+SymbolCategoryTest::~SymbolCategoryTest() {
delete m_pTestee;
}
// SetUp() will be called immediately before each test.
-void SymbolCategoryTest::SetUp()
-{
+void SymbolCategoryTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void SymbolCategoryTest::TearDown()
-{
+void SymbolCategoryTest::TearDown() {
}
//==========================================================================//
diff --git a/unittests/SymbolCategoryTest.h b/unittests/SymbolCategoryTest.h
index a7109ed..39dabd7 100644
--- a/unittests/SymbolCategoryTest.h
+++ b/unittests/SymbolCategoryTest.h
@@ -11,23 +11,20 @@
#include <gtest.h>
-namespace mcld
-{
+namespace mcld {
class SymbolCategory;
-} // namespace for mcld
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
/** \class SymbolCategoryTest
* \brief The testcases of symbol category.
*
* \see SymbolCategory
*/
-class SymbolCategoryTest : public ::testing::Test
-{
-public:
+class SymbolCategoryTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
SymbolCategoryTest();
@@ -40,11 +37,10 @@
// TearDown() will be called immediately after each test.
virtual void TearDown();
-protected:
+ protected:
mcld::SymbolCategory* m_pTestee;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-
diff --git a/unittests/SymbolTableTest.cpp b/unittests/SymbolTableTest.cpp
index 2dc5143..a601d07 100644
--- a/unittests/SymbolTableTest.cpp
+++ b/unittests/SymbolTableTest.cpp
@@ -6,34 +6,29 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/LD/SymbolTable.h>
+#include "mcld/LD/SymbolTable.h"
#include "SymbolTableTest.h"
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-SymbolTableTest::SymbolTableTest()
-{
+SymbolTableTest::SymbolTableTest() {
// create testee. modify it if need
m_pTestee = new SymbolTable<>(m_StrTable);
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-SymbolTableTest::~SymbolTableTest()
-{
+SymbolTableTest::~SymbolTableTest() {
delete m_pTestee;
}
// SetUp() will be called immediately before each test.
-void SymbolTableTest::SetUp()
-{
+void SymbolTableTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void SymbolTableTest::TearDown()
-{
+void SymbolTableTest::TearDown() {
}
//==========================================================================//
diff --git a/unittests/SymbolTableTest.h b/unittests/SymbolTableTest.h
index 39e8751..4a4ce70 100644
--- a/unittests/SymbolTableTest.h
+++ b/unittests/SymbolTableTest.h
@@ -11,23 +11,20 @@
#include "mcld/LD/StringTable.h"
#include <gtest.h>
-namespace mcld
-{
- template <template <class> class, class>
- class SymbolTable;
-} // namespace for mcld
+namespace mcld {
+template <template <class> class, class>
+class SymbolTable;
+} // namespace for mcld
-namespace mcldtest
-{
+namespace mcldtest {
/** \class SymbolTableTest
* \brief
*
* \see SymbolTable
*/
-class SymbolTableTest : public ::testing::Test
-{
-public:
+class SymbolTableTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
SymbolTableTest();
@@ -40,11 +37,11 @@
// TearDown() will be called immediately after each test.
virtual void TearDown();
-protected:
+ protected:
mcld::SymbolTable<>* m_pTestee;
mcld::StringTable m_StrTable;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
diff --git a/unittests/SystemUtilsTest.cpp b/unittests/SystemUtilsTest.cpp
index 1222794..3923aee 100644
--- a/unittests/SystemUtilsTest.cpp
+++ b/unittests/SystemUtilsTest.cpp
@@ -6,37 +6,31 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/Support/SystemUtils.h>
+#include "mcld/Support/SystemUtils.h"
#include "SystemUtilsTest.h"
using namespace mcld;
using namespace mcld::test;
-
// Constructor can do set-up work for all test here.
-SystemUtilsTest::SystemUtilsTest()
-{
+SystemUtilsTest::SystemUtilsTest() {
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-SystemUtilsTest::~SystemUtilsTest()
-{
+SystemUtilsTest::~SystemUtilsTest() {
}
// SetUp() will be called immediately before each test.
-void SystemUtilsTest::SetUp()
-{
+void SystemUtilsTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void SystemUtilsTest::TearDown()
-{
+void SystemUtilsTest::TearDown() {
}
//===----------------------------------------------------------------------===//
// Testcases
//===----------------------------------------------------------------------===//
-TEST_F( SystemUtilsTest, test_strerror) {
+TEST_F(SystemUtilsTest, test_strerror) {
ASSERT_TRUE(NULL != mcld::sys::strerror(0));
}
-
diff --git a/unittests/SystemUtilsTest.h b/unittests/SystemUtilsTest.h
index 660d7bb..ce0d204 100644
--- a/unittests/SystemUtilsTest.h
+++ b/unittests/SystemUtilsTest.h
@@ -14,9 +14,8 @@
namespace mcld {
namespace test {
-class SystemUtilsTest : public ::testing::Test
-{
-public:
+class SystemUtilsTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
SystemUtilsTest();
@@ -30,8 +29,7 @@
virtual void TearDown();
};
-} // namespace of test
-} // namespace of mcld
+} // namespace of test
+} // namespace of mcld
#endif
-
diff --git a/unittests/TargetMachineTest.cpp b/unittests/TargetMachineTest.cpp
index 85950a9..8501d84 100644
--- a/unittests/TargetMachineTest.cpp
+++ b/unittests/TargetMachineTest.cpp
@@ -11,32 +11,26 @@
using namespace mcld;
using namespace mcldTEST;
-
// Constructor can do set-up work for all test here.
-TargetMachineTest::TargetMachineTest()
-{
+TargetMachineTest::TargetMachineTest() {
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-TargetMachineTest::~TargetMachineTest()
-{
+TargetMachineTest::~TargetMachineTest() {
}
// SetUp() will be called immediately before each test.
-void TargetMachineTest::SetUp()
-{
+void TargetMachineTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void TargetMachineTest::TearDown()
-{
+void TargetMachineTest::TearDown() {
}
//==========================================================================//
// Testcases
//
-TEST_F( TargetMachineTest, addPassesToEmitFile ) {
- mcld::addPassesToEmitFile();
+TEST_F(TargetMachineTest, addPassesToEmitFile) {
+ mcld::addPassesToEmitFile();
}
-
diff --git a/unittests/TargetMachineTest.h b/unittests/TargetMachineTest.h
index 88a44dc..3d19e68 100644
--- a/unittests/TargetMachineTest.h
+++ b/unittests/TargetMachineTest.h
@@ -11,31 +11,28 @@
#include "mcld/Target/TargetMachine.h"
#include <gtest.h>
-namespace mcldTEST
-{
+namespace mcldTEST {
/** \class TargetMachineTest
* \brief
*
* \see TargetMachine
*/
-class TargetMachineTest : public ::testing::Test
-{
-public:
- // Constructor can do set-up work for all test here.
- TargetMachineTest();
+class TargetMachineTest : public ::testing::Test {
+ public:
+ // Constructor can do set-up work for all test here.
+ TargetMachineTest();
- // Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~TargetMachineTest();
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~TargetMachineTest();
- // SetUp() will be called immediately before each test.
- virtual void SetUp();
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
- // TearDown() will be called immediately after each test.
- virtual void TearDown();
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
};
-} // namespace of BOLDTEST
+} // namespace of BOLDTEST
#endif
-
diff --git a/unittests/UniqueGCFactoryBaseTest.cpp b/unittests/UniqueGCFactoryBaseTest.cpp
index a6f7289..5480eab 100644
--- a/unittests/UniqueGCFactoryBaseTest.cpp
+++ b/unittests/UniqueGCFactoryBaseTest.cpp
@@ -6,92 +6,91 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/MC/ContextFactory.h>
-#include <mcld/Support/MemoryAreaFactory.h>
-#include <mcld/Support/TargetSelect.h>
-#include <mcld/Support/Path.h>
+#include "mcld/MC/ContextFactory.h"
+#include "mcld/Support/MemoryAreaFactory.h"
+#include "mcld/Support/TargetSelect.h"
+#include "mcld/Support/Path.h"
#include "UniqueGCFactoryBaseTest.h"
using namespace mcld;
using namespace mcldtest;
-
// Constructor can do set-up work for all test here.
-UniqueGCFactoryBaseTest::UniqueGCFactoryBaseTest()
-{
+UniqueGCFactoryBaseTest::UniqueGCFactoryBaseTest() {
m_pConfig = new LinkerConfig("arm-none-linux-gnueabi");
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-UniqueGCFactoryBaseTest::~UniqueGCFactoryBaseTest()
-{
+UniqueGCFactoryBaseTest::~UniqueGCFactoryBaseTest() {
delete m_pConfig;
}
// SetUp() will be called immediately before each test.
-void UniqueGCFactoryBaseTest::SetUp()
-{
+void UniqueGCFactoryBaseTest::SetUp() {
}
// TearDown() will be called immediately after each test.
-void UniqueGCFactoryBaseTest::TearDown()
-{
+void UniqueGCFactoryBaseTest::TearDown() {
}
//==========================================================================//
// Testcases
//
-TEST_F( UniqueGCFactoryBaseTest, number_constructor ) {
- ContextFactory *contextFactory = new ContextFactory(10);
- contextFactory->produce("/");
- contextFactory->produce("ab/c");
- ASSERT_TRUE( 2 == contextFactory->size());
- delete contextFactory;
+TEST_F(UniqueGCFactoryBaseTest, number_constructor) {
+ ContextFactory* contextFactory = new ContextFactory(10);
+ contextFactory->produce("/");
+ contextFactory->produce("ab/c");
+ ASSERT_TRUE(2 == contextFactory->size());
+ delete contextFactory;
}
-TEST_F( UniqueGCFactoryBaseTest, unique_produce ) {
- ContextFactory *contextFactory = new ContextFactory(10);
- LDContext* context1 = contextFactory->produce("/");
- contextFactory->produce("ab/c");
- ASSERT_TRUE( 2 == contextFactory->size());
- LDContext* context2 = contextFactory->produce("/");
- ASSERT_EQ( context1, context2 );
- delete contextFactory;
+TEST_F(UniqueGCFactoryBaseTest, unique_produce) {
+ ContextFactory* contextFactory = new ContextFactory(10);
+ LDContext* context1 = contextFactory->produce("/");
+ contextFactory->produce("ab/c");
+ ASSERT_TRUE(2 == contextFactory->size());
+ LDContext* context2 = contextFactory->produce("/");
+ ASSERT_EQ(context1, context2);
+ delete contextFactory;
}
-TEST_F( UniqueGCFactoryBaseTest, unique_produce2 ) {
- ContextFactory *contextFactory = new ContextFactory(10);
- LDContext* context1 = contextFactory->produce("abc/def");
- contextFactory->produce("ab/c");
- ASSERT_TRUE( 2 == contextFactory->size());
- LDContext* context2 = contextFactory->produce("ttt/../abc/def");
- ASSERT_EQ( context1, context2 );
- delete contextFactory;
+TEST_F(UniqueGCFactoryBaseTest, unique_produce2) {
+ ContextFactory* contextFactory = new ContextFactory(10);
+ LDContext* context1 = contextFactory->produce("abc/def");
+ contextFactory->produce("ab/c");
+ ASSERT_TRUE(2 == contextFactory->size());
+ LDContext* context2 = contextFactory->produce("ttt/../abc/def");
+ ASSERT_EQ(context1, context2);
+ delete contextFactory;
}
-TEST_F( UniqueGCFactoryBaseTest, iterator )
-{
- sys::fs::Path path1(TOPDIR), path2(TOPDIR);
- path1.append("unittests/test.txt");
- path2.append("unittests/test2.txt");
+TEST_F(UniqueGCFactoryBaseTest, iterator) {
+ sys::fs::Path path1(TOPDIR), path2(TOPDIR);
+ path1.append("unittests/test.txt");
+ path2.append("unittests/test2.txt");
- MemoryAreaFactory* memFactory = new MemoryAreaFactory(10);
- MemoryArea* area1 = memFactory->produce(path1, FileHandle::ReadOnly);
- MemoryArea* area2 = memFactory->produce(path2, FileHandle::ReadOnly);
- ASSERT_NE( area1, area2);
+ MemoryAreaFactory* memFactory = new MemoryAreaFactory(10);
+ MemoryArea* area1 =
+ memFactory->produce(path1, FileHandle::OpenMode(FileHandle::ReadOnly),
+ FileHandle::Permission(FileHandle::System));
+ MemoryArea* area2 =
+ memFactory->produce(path2, FileHandle::OpenMode(FileHandle::ReadOnly),
+ FileHandle::Permission(FileHandle::System));
+ ASSERT_NE(area1, area2);
- MemoryArea* area3 = memFactory->produce(path1, FileHandle::ReadOnly);
+ MemoryArea* area3 =
+ memFactory->produce(path1, FileHandle::OpenMode(FileHandle::ReadOnly),
+ FileHandle::Permission(FileHandle::System));
- ASSERT_EQ(area1, area3);
- ASSERT_FALSE( memFactory->empty());
- ASSERT_TRUE( 2 == memFactory->size());
- MemoryAreaFactory::iterator aIter = memFactory->begin();
- ASSERT_EQ( area1, &(*aIter));
- ++aIter;
- ASSERT_EQ( area2, &(*aIter));
- ++aIter;
- MemoryAreaFactory::iterator aEnd = memFactory->end();
- ASSERT_TRUE( aEnd == aIter);
- delete memFactory;
+ ASSERT_EQ(area1, area3);
+ ASSERT_FALSE(memFactory->empty());
+ ASSERT_TRUE(2 == memFactory->size());
+ MemoryAreaFactory::iterator aIter = memFactory->begin();
+ ASSERT_EQ(area1, &(*aIter));
+ ++aIter;
+ ASSERT_EQ(area2, &(*aIter));
+ ++aIter;
+ MemoryAreaFactory::iterator aEnd = memFactory->end();
+ ASSERT_TRUE(aEnd == aIter);
+ delete memFactory;
}
-
diff --git a/unittests/UniqueGCFactoryBaseTest.h b/unittests/UniqueGCFactoryBaseTest.h
index c2f1c1b..14ba2e0 100644
--- a/unittests/UniqueGCFactoryBaseTest.h
+++ b/unittests/UniqueGCFactoryBaseTest.h
@@ -9,22 +9,20 @@
#ifndef UNIQUE_GCFACTORYBASE_TEST_H
#define UNIQUE_GCFACTORYBASE_TEST_H
-#include <mcld/Support/UniqueGCFactory.h>
-#include <mcld/LinkerConfig.h>
-#include <mcld/LD/DiagnosticPrinter.h>
+#include "mcld/Support/UniqueGCFactory.h"
+#include "mcld/LinkerConfig.h"
+#include "mcld/LD/DiagnosticPrinter.h"
#include <gtest.h>
-namespace mcldtest
-{
+namespace mcldtest {
/** \class UniqueGCFactoryBaseTest
* - check the unique of key.
* - make sure the key associates with the same storage of value.
* - check if all functions in the GCFactoryBase are available.
*/
-class UniqueGCFactoryBaseTest : public ::testing::Test
-{
-public:
+class UniqueGCFactoryBaseTest : public ::testing::Test {
+ public:
// Constructor can do set-up work for all test here.
UniqueGCFactoryBaseTest();
@@ -37,11 +35,10 @@
// TearDown() will be called immediately after each test.
virtual void TearDown();
-private:
+ private:
mcld::LinkerConfig* m_pConfig;
};
-} // namespace of mcldtest
+} // namespace of mcldtest
#endif
-