|
@@ -58,26 +58,38 @@ const size_t Name::MAX_LABELS;
|
|
|
*/
|
|
|
|
|
|
namespace {
|
|
|
+
|
|
|
+class DeleterType {
|
|
|
+public:
|
|
|
+ void operator()(int *i) const {
|
|
|
+ delete i;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+typedef DomainTree<int, DeleterType> TestDomainTree;
|
|
|
+typedef DomainTreeNode<int, DeleterType> TestDomainTreeNode;
|
|
|
+typedef DomainTreeNodeChain<int, DeleterType> TestDomainTreeNodeChain;
|
|
|
+
|
|
|
class TreeHolder {
|
|
|
public:
|
|
|
- TreeHolder(util::MemorySegment& mem_sgmt, DomainTree<int>* tree) :
|
|
|
+ TreeHolder(util::MemorySegment& mem_sgmt, TestDomainTree* tree) :
|
|
|
mem_sgmt_(mem_sgmt), tree_(tree)
|
|
|
{}
|
|
|
~TreeHolder() {
|
|
|
- DomainTree<int>::destroy(mem_sgmt_, tree_);
|
|
|
+ TestDomainTree::destroy(mem_sgmt_, tree_);
|
|
|
}
|
|
|
- DomainTree<int>* get() { return (tree_); }
|
|
|
+ TestDomainTree* get() { return (tree_); }
|
|
|
private:
|
|
|
util::MemorySegment& mem_sgmt_;
|
|
|
- DomainTree<int>* tree_;
|
|
|
+ TestDomainTree* tree_;
|
|
|
};
|
|
|
|
|
|
class DomainTreeTest : public::testing::Test {
|
|
|
protected:
|
|
|
DomainTreeTest() :
|
|
|
- rbtree_holder_(mem_sgmt_, DomainTree<int>::create(mem_sgmt_)),
|
|
|
+ rbtree_holder_(mem_sgmt_, TestDomainTree::create(mem_sgmt_)),
|
|
|
rbtree_expose_empty_node_holder_(mem_sgmt_,
|
|
|
- DomainTree<int>::create(mem_sgmt_, true)),
|
|
|
+ TestDomainTree::create(mem_sgmt_, true)),
|
|
|
rbtree(*rbtree_holder_.get()),
|
|
|
rbtree_expose_empty_node(*rbtree_expose_empty_node_holder_.get()),
|
|
|
crbtnode(NULL)
|
|
@@ -88,11 +100,11 @@ protected:
|
|
|
int name_count = sizeof(domain_names) / sizeof(domain_names[0]);
|
|
|
for (int i = 0; i < name_count; ++i) {
|
|
|
rbtree.insert(mem_sgmt_, Name(domain_names[i]), &rbtnode);
|
|
|
- rbtnode->setData(DomainTreeNode<int>::NodeDataPtr(new int(i + 1)));
|
|
|
+ rbtnode->setData(new int(i + 1));
|
|
|
|
|
|
rbtree_expose_empty_node.insert(mem_sgmt_, Name(domain_names[i]),
|
|
|
&rbtnode);
|
|
|
- rbtnode->setData(DomainTreeNode<int>::NodeDataPtr(new int(i + 1)));
|
|
|
+ rbtnode->setData(new int(i + 1));
|
|
|
|
|
|
}
|
|
|
}
|
|
@@ -100,10 +112,10 @@ protected:
|
|
|
util::MemorySegmentLocal mem_sgmt_;
|
|
|
TreeHolder rbtree_holder_;
|
|
|
TreeHolder rbtree_expose_empty_node_holder_;
|
|
|
- DomainTree<int>& rbtree;
|
|
|
- DomainTree<int>& rbtree_expose_empty_node;
|
|
|
- DomainTreeNode<int>* rbtnode;
|
|
|
- const DomainTreeNode<int>* crbtnode;
|
|
|
+ TestDomainTree& rbtree;
|
|
|
+ TestDomainTree& rbtree_expose_empty_node;
|
|
|
+ TestDomainTreeNode* rbtnode;
|
|
|
+ const TestDomainTreeNode* crbtnode;
|
|
|
};
|
|
|
|
|
|
TEST_F(DomainTreeTest, nodeCount) {
|
|
@@ -116,97 +128,97 @@ TEST_F(DomainTreeTest, nodeCount) {
|
|
|
}
|
|
|
|
|
|
TEST_F(DomainTreeTest, setGetData) {
|
|
|
- rbtnode->setData(DomainTreeNode<int>::NodeDataPtr(new int(11)));
|
|
|
+ rbtnode->setData(new int(11));
|
|
|
EXPECT_EQ(11, *(rbtnode->getData()));
|
|
|
}
|
|
|
|
|
|
TEST_F(DomainTreeTest, insertNames) {
|
|
|
- EXPECT_EQ(DomainTree<int>::ALREADYEXISTS, rbtree.insert(mem_sgmt_,
|
|
|
+ EXPECT_EQ(TestDomainTree::ALREADYEXISTS, rbtree.insert(mem_sgmt_,
|
|
|
Name("d.e.f"),
|
|
|
&rbtnode));
|
|
|
EXPECT_EQ(Name("d.e.f"), rbtnode->getName());
|
|
|
EXPECT_EQ(15, rbtree.getNodeCount());
|
|
|
|
|
|
// insert not exist node
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("0"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("0"),
|
|
|
&rbtnode));
|
|
|
EXPECT_EQ(Name("0"), rbtnode->getName());
|
|
|
EXPECT_EQ(16, rbtree.getNodeCount());
|
|
|
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_,
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_,
|
|
|
Name("example.com"),
|
|
|
&rbtnode));
|
|
|
EXPECT_EQ(17, rbtree.getNodeCount());
|
|
|
- rbtnode->setData(DomainTreeNode<int>::NodeDataPtr(new int(12)));
|
|
|
+ rbtnode->setData(new int(12));
|
|
|
|
|
|
// return ALREADYEXISTS, since node "example.com" already has
|
|
|
// been explicitly inserted
|
|
|
- EXPECT_EQ(DomainTree<int>::ALREADYEXISTS, rbtree.insert(mem_sgmt_,
|
|
|
+ EXPECT_EQ(TestDomainTree::ALREADYEXISTS, rbtree.insert(mem_sgmt_,
|
|
|
Name("example.com"),
|
|
|
&rbtnode));
|
|
|
EXPECT_EQ(17, rbtree.getNodeCount());
|
|
|
|
|
|
// split the node "d.e.f"
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("k.e.f"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("k.e.f"),
|
|
|
&rbtnode));
|
|
|
EXPECT_EQ(Name("k"), rbtnode->getName());
|
|
|
EXPECT_EQ(19, rbtree.getNodeCount());
|
|
|
|
|
|
// split the node "g.h"
|
|
|
- EXPECT_EQ(DomainTree<int>::ALREADYEXISTS, rbtree.insert(mem_sgmt_, Name("h"),
|
|
|
+ EXPECT_EQ(TestDomainTree::ALREADYEXISTS, rbtree.insert(mem_sgmt_, Name("h"),
|
|
|
&rbtnode));
|
|
|
EXPECT_EQ(Name("h"), rbtnode->getName());
|
|
|
EXPECT_EQ(20, rbtree.getNodeCount());
|
|
|
|
|
|
// add child domain
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_,
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_,
|
|
|
Name("m.p.w.y.d.e.f"),
|
|
|
&rbtnode));
|
|
|
EXPECT_EQ(Name("m"), rbtnode->getName());
|
|
|
EXPECT_EQ(21, rbtree.getNodeCount());
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_,
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_,
|
|
|
Name("n.p.w.y.d.e.f"),
|
|
|
&rbtnode));
|
|
|
EXPECT_EQ(Name("n"), rbtnode->getName());
|
|
|
EXPECT_EQ(22, rbtree.getNodeCount());
|
|
|
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("l.a"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("l.a"),
|
|
|
&rbtnode));
|
|
|
EXPECT_EQ(Name("l"), rbtnode->getName());
|
|
|
EXPECT_EQ(23, rbtree.getNodeCount());
|
|
|
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("r.d.e.f"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("r.d.e.f"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("s.d.e.f"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("s.d.e.f"),
|
|
|
&rbtnode));
|
|
|
EXPECT_EQ(25, rbtree.getNodeCount());
|
|
|
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_,
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_,
|
|
|
Name("h.w.y.d.e.f"),
|
|
|
&rbtnode));
|
|
|
|
|
|
// add more nodes one by one to cover leftRotate and rightRotate
|
|
|
- EXPECT_EQ(DomainTree<int>::ALREADYEXISTS, rbtree.insert(mem_sgmt_, Name("f"),
|
|
|
+ EXPECT_EQ(TestDomainTree::ALREADYEXISTS, rbtree.insert(mem_sgmt_, Name("f"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("m"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("m"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("nm"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("nm"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("om"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("om"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("k"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("k"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("l"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("l"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("fe"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("fe"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("ge"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("ge"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("i"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("i"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("ae"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("ae"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_, Name("n"),
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("n"),
|
|
|
&rbtnode));
|
|
|
}
|
|
|
|
|
@@ -216,76 +228,76 @@ TEST_F(DomainTreeTest, subTreeRoot) {
|
|
|
// that when a node was fissioned, FLAG_SUBTREE_ROOT was not being
|
|
|
// copied correctly.
|
|
|
|
|
|
- EXPECT_EQ(DomainTree<int>::ALREADYEXISTS,
|
|
|
+ EXPECT_EQ(TestDomainTree::ALREADYEXISTS,
|
|
|
rbtree_expose_empty_node.insert(mem_sgmt_, Name("d.e.f"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS,
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS,
|
|
|
rbtree_expose_empty_node.insert(mem_sgmt_, Name("0"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS,
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS,
|
|
|
rbtree_expose_empty_node.insert(mem_sgmt_, Name("example.com"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::ALREADYEXISTS,
|
|
|
+ EXPECT_EQ(TestDomainTree::ALREADYEXISTS,
|
|
|
rbtree_expose_empty_node.insert(mem_sgmt_, Name("example.com"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS,
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS,
|
|
|
rbtree_expose_empty_node.insert(mem_sgmt_, Name("k.e.f"),
|
|
|
&rbtnode));
|
|
|
|
|
|
// "g.h" is not a subtree root
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
rbtree_expose_empty_node.find(Name("g.h"), &rbtnode));
|
|
|
- EXPECT_FALSE(rbtnode->getFlag(DomainTreeNode<int>::FLAG_SUBTREE_ROOT));
|
|
|
+ EXPECT_FALSE(rbtnode->getFlag(TestDomainTreeNode::FLAG_SUBTREE_ROOT));
|
|
|
|
|
|
// fission the node "g.h"
|
|
|
- EXPECT_EQ(DomainTree<int>::ALREADYEXISTS,
|
|
|
+ EXPECT_EQ(TestDomainTree::ALREADYEXISTS,
|
|
|
rbtree_expose_empty_node.insert(mem_sgmt_, Name("h"),
|
|
|
&rbtnode));
|
|
|
|
|
|
// the node "h" (h.down_ -> "g") should not be a subtree root. "g"
|
|
|
// should be a subtree root.
|
|
|
- EXPECT_FALSE(rbtnode->getFlag(DomainTreeNode<int>::FLAG_SUBTREE_ROOT));
|
|
|
+ EXPECT_FALSE(rbtnode->getFlag(TestDomainTreeNode::FLAG_SUBTREE_ROOT));
|
|
|
|
|
|
// "g.h" should be a subtree root now.
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
rbtree_expose_empty_node.find(Name("g.h"), &rbtnode));
|
|
|
- EXPECT_TRUE(rbtnode->getFlag(DomainTreeNode<int>::FLAG_SUBTREE_ROOT));
|
|
|
+ EXPECT_TRUE(rbtnode->getFlag(TestDomainTreeNode::FLAG_SUBTREE_ROOT));
|
|
|
}
|
|
|
|
|
|
TEST_F(DomainTreeTest, findName) {
|
|
|
// find const rbtnode
|
|
|
// exact match
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH, rbtree.find(Name("a"), &crbtnode));
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH, rbtree.find(Name("a"), &crbtnode));
|
|
|
EXPECT_EQ(Name("a"), crbtnode->getName());
|
|
|
|
|
|
// not found
|
|
|
- EXPECT_EQ(DomainTree<int>::NOTFOUND, rbtree.find(Name("d.e.f"), &crbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::NOTFOUND, rbtree.find(Name("y.d.e.f"), &crbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::NOTFOUND, rbtree.find(Name("x"), &crbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::NOTFOUND, rbtree.find(Name("m.n"), &crbtnode));
|
|
|
+ EXPECT_EQ(TestDomainTree::NOTFOUND, rbtree.find(Name("d.e.f"), &crbtnode));
|
|
|
+ EXPECT_EQ(TestDomainTree::NOTFOUND, rbtree.find(Name("y.d.e.f"), &crbtnode));
|
|
|
+ EXPECT_EQ(TestDomainTree::NOTFOUND, rbtree.find(Name("x"), &crbtnode));
|
|
|
+ EXPECT_EQ(TestDomainTree::NOTFOUND, rbtree.find(Name("m.n"), &crbtnode));
|
|
|
|
|
|
// if we expose empty node, we can get the empty node created during insert
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
rbtree_expose_empty_node.find(Name("d.e.f"), &crbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
rbtree_expose_empty_node.find(Name("w.y.d.e.f"), &crbtnode));
|
|
|
|
|
|
// partial match
|
|
|
- EXPECT_EQ(DomainTree<int>::PARTIALMATCH, rbtree.find(Name("m.b"), &crbtnode));
|
|
|
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH, rbtree.find(Name("m.b"), &crbtnode));
|
|
|
EXPECT_EQ(Name("b"), crbtnode->getName());
|
|
|
- EXPECT_EQ(DomainTree<int>::PARTIALMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH,
|
|
|
rbtree_expose_empty_node.find(Name("m.d.e.f"), &crbtnode));
|
|
|
|
|
|
// find rbtnode
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH, rbtree.find(Name("q.w.y.d.e.f"),
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH, rbtree.find(Name("q.w.y.d.e.f"),
|
|
|
&rbtnode));
|
|
|
EXPECT_EQ(Name("q"), rbtnode->getName());
|
|
|
}
|
|
|
|
|
|
TEST_F(DomainTreeTest, findError) {
|
|
|
// For the version that takes a node chain, the chain must be empty.
|
|
|
- DomainTreeNodeChain<int> chain;
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH, rbtree.find(Name("a"), &crbtnode,
|
|
|
+ TestDomainTreeNodeChain chain;
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH, rbtree.find(Name("a"), &crbtnode,
|
|
|
chain));
|
|
|
// trying to reuse the same chain. it should result in an exception.
|
|
|
EXPECT_THROW(rbtree.find(Name("a"), &crbtnode, chain),
|
|
@@ -293,94 +305,94 @@ TEST_F(DomainTreeTest, findError) {
|
|
|
}
|
|
|
|
|
|
TEST_F(DomainTreeTest, flags) {
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt_,
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_,
|
|
|
Name("flags.example"),
|
|
|
&rbtnode));
|
|
|
|
|
|
// by default, flags are all off
|
|
|
- EXPECT_FALSE(rbtnode->getFlag(DomainTreeNode<int>::FLAG_CALLBACK));
|
|
|
+ EXPECT_FALSE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
|
|
|
|
|
|
// set operation, by default it enables the flag
|
|
|
- rbtnode->setFlag(DomainTreeNode<int>::FLAG_CALLBACK);
|
|
|
- EXPECT_TRUE(rbtnode->getFlag(DomainTreeNode<int>::FLAG_CALLBACK));
|
|
|
+ rbtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK);
|
|
|
+ EXPECT_TRUE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
|
|
|
|
|
|
// try disable the flag explicitly
|
|
|
- rbtnode->setFlag(DomainTreeNode<int>::FLAG_CALLBACK, false);
|
|
|
- EXPECT_FALSE(rbtnode->getFlag(DomainTreeNode<int>::FLAG_CALLBACK));
|
|
|
+ rbtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK, false);
|
|
|
+ EXPECT_FALSE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
|
|
|
|
|
|
// try enable the flag explicitly
|
|
|
- rbtnode->setFlag(DomainTreeNode<int>::FLAG_CALLBACK, true);
|
|
|
- EXPECT_TRUE(rbtnode->getFlag(DomainTreeNode<int>::FLAG_CALLBACK));
|
|
|
+ rbtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK, true);
|
|
|
+ EXPECT_TRUE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
|
|
|
|
|
|
// setting an unknown flag will trigger an exception
|
|
|
- EXPECT_THROW(rbtnode->setFlag(static_cast<DomainTreeNode<int>::Flags>(2), true),
|
|
|
+ EXPECT_THROW(rbtnode->setFlag(static_cast<TestDomainTreeNode::Flags>(2), true),
|
|
|
isc::InvalidParameter);
|
|
|
}
|
|
|
|
|
|
bool
|
|
|
-testCallback(const DomainTreeNode<int>&, bool* callback_checker) {
|
|
|
+testCallback(const TestDomainTreeNode&, bool* callback_checker) {
|
|
|
*callback_checker = true;
|
|
|
return (false);
|
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
|
void
|
|
|
-performCallbackTest(DomainTree<int>& rbtree,
|
|
|
+performCallbackTest(TestDomainTree& rbtree,
|
|
|
util::MemorySegmentLocal& mem_sgmt,
|
|
|
const T& name_called,
|
|
|
const T& name_not_called)
|
|
|
{
|
|
|
- DomainTreeNode<int>* rbtnode;
|
|
|
- const DomainTreeNode<int>* crbtnode;
|
|
|
+ TestDomainTreeNode* rbtnode;
|
|
|
+ const TestDomainTreeNode* crbtnode;
|
|
|
|
|
|
// by default callback isn't enabled
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt,
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt,
|
|
|
Name("callback.example"),
|
|
|
&rbtnode));
|
|
|
- rbtnode->setData(DomainTreeNode<int>::NodeDataPtr(new int(1)));
|
|
|
- EXPECT_FALSE(rbtnode->getFlag(DomainTreeNode<int>::FLAG_CALLBACK));
|
|
|
+ rbtnode->setData(new int(1));
|
|
|
+ EXPECT_FALSE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
|
|
|
|
|
|
// enable/re-disable callback
|
|
|
- rbtnode->setFlag(DomainTreeNode<int>::FLAG_CALLBACK);
|
|
|
- EXPECT_TRUE(rbtnode->getFlag(DomainTreeNode<int>::FLAG_CALLBACK));
|
|
|
- rbtnode->setFlag(DomainTreeNode<int>::FLAG_CALLBACK, false);
|
|
|
- EXPECT_FALSE(rbtnode->getFlag(DomainTreeNode<int>::FLAG_CALLBACK));
|
|
|
+ rbtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK);
|
|
|
+ EXPECT_TRUE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
|
|
|
+ rbtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK, false);
|
|
|
+ EXPECT_FALSE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
|
|
|
|
|
|
// enable again for subsequent tests
|
|
|
- rbtnode->setFlag(DomainTreeNode<int>::FLAG_CALLBACK);
|
|
|
+ rbtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK);
|
|
|
// add more levels below and above the callback node for partial match.
|
|
|
- DomainTreeNode<int>* subrbtnode;
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, rbtree.insert(mem_sgmt,
|
|
|
+ TestDomainTreeNode* subrbtnode;
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt,
|
|
|
Name("sub.callback.example"),
|
|
|
&subrbtnode));
|
|
|
- subrbtnode->setData(DomainTreeNode<int>::NodeDataPtr(new int(2)));
|
|
|
- DomainTreeNode<int>* parentrbtnode;
|
|
|
- EXPECT_EQ(DomainTree<int>::ALREADYEXISTS, rbtree.insert(mem_sgmt,
|
|
|
+ subrbtnode->setData(new int(2));
|
|
|
+ TestDomainTreeNode* parentrbtnode;
|
|
|
+ EXPECT_EQ(TestDomainTree::ALREADYEXISTS, rbtree.insert(mem_sgmt,
|
|
|
Name("example"),
|
|
|
&parentrbtnode));
|
|
|
// the child/parent nodes shouldn't "inherit" the callback flag.
|
|
|
// "rbtnode" may be invalid due to the insertion, so we need to re-find
|
|
|
// it.
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH, rbtree.find(Name("callback.example"),
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH, rbtree.find(Name("callback.example"),
|
|
|
&rbtnode));
|
|
|
- EXPECT_TRUE(rbtnode->getFlag(DomainTreeNode<int>::FLAG_CALLBACK));
|
|
|
- EXPECT_FALSE(subrbtnode->getFlag(DomainTreeNode<int>::FLAG_CALLBACK));
|
|
|
- EXPECT_FALSE(parentrbtnode->getFlag(DomainTreeNode<int>::FLAG_CALLBACK));
|
|
|
+ EXPECT_TRUE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
|
|
|
+ EXPECT_FALSE(subrbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
|
|
|
+ EXPECT_FALSE(parentrbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
|
|
|
|
|
|
// check if the callback is called from find()
|
|
|
- DomainTreeNodeChain<int> node_path1;
|
|
|
+ TestDomainTreeNodeChain node_path1;
|
|
|
bool callback_called = false;
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
rbtree.find(name_called, &crbtnode, node_path1,
|
|
|
testCallback, &callback_called));
|
|
|
EXPECT_TRUE(callback_called);
|
|
|
|
|
|
// enable callback at the parent node, but it doesn't have data so
|
|
|
// the callback shouldn't be called.
|
|
|
- DomainTreeNodeChain<int> node_path2;
|
|
|
- parentrbtnode->setFlag(DomainTreeNode<int>::FLAG_CALLBACK);
|
|
|
+ TestDomainTreeNodeChain node_path2;
|
|
|
+ parentrbtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK);
|
|
|
callback_called = false;
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
rbtree.find(name_not_called, &crbtnode, node_path2,
|
|
|
testCallback, &callback_called));
|
|
|
EXPECT_FALSE(callback_called);
|
|
@@ -403,19 +415,19 @@ TEST_F(DomainTreeTest, callbackLabelSequence) {
|
|
|
}
|
|
|
|
|
|
TEST_F(DomainTreeTest, chainLevel) {
|
|
|
- DomainTreeNodeChain<int> chain;
|
|
|
+ TestDomainTreeNodeChain chain;
|
|
|
|
|
|
// by default there should be no level in the chain.
|
|
|
EXPECT_EQ(0, chain.getLevelCount());
|
|
|
|
|
|
// insert one node to the tree and find it. there should be exactly
|
|
|
// one level in the chain.
|
|
|
- TreeHolder tree_holder(mem_sgmt_, DomainTree<int>::create(mem_sgmt_, true));
|
|
|
- DomainTree<int>& tree(*tree_holder.get());
|
|
|
+ TreeHolder tree_holder(mem_sgmt_, TestDomainTree::create(mem_sgmt_, true));
|
|
|
+ TestDomainTree& tree(*tree_holder.get());
|
|
|
Name node_name(Name::ROOT_NAME());
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, tree.insert(mem_sgmt_, node_name,
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, tree.insert(mem_sgmt_, node_name,
|
|
|
&rbtnode));
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
tree.find(node_name, &crbtnode, chain));
|
|
|
EXPECT_EQ(1, chain.getLevelCount());
|
|
|
|
|
@@ -436,10 +448,10 @@ TEST_F(DomainTreeTest, chainLevel) {
|
|
|
*/
|
|
|
for (unsigned int i = 2; i <= Name::MAX_LABELS; ++i) {
|
|
|
node_name = Name("a.").concatenate(node_name);
|
|
|
- EXPECT_EQ(DomainTree<int>::SUCCESS, tree.insert(mem_sgmt_, node_name,
|
|
|
+ EXPECT_EQ(TestDomainTree::SUCCESS, tree.insert(mem_sgmt_, node_name,
|
|
|
&rbtnode));
|
|
|
- DomainTreeNodeChain<int> found_chain;
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ TestDomainTreeNodeChain found_chain;
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
tree.find(node_name, &crbtnode, found_chain));
|
|
|
EXPECT_EQ(i, found_chain.getLevelCount());
|
|
|
}
|
|
@@ -453,7 +465,7 @@ TEST_F(DomainTreeTest, chainLevel) {
|
|
|
|
|
|
TEST_F(DomainTreeTest, getAbsoluteNameError) {
|
|
|
// an empty chain isn't allowed.
|
|
|
- DomainTreeNodeChain<int> chain;
|
|
|
+ TestDomainTreeNodeChain chain;
|
|
|
EXPECT_THROW(chain.getAbsoluteName(), BadValue);
|
|
|
}
|
|
|
|
|
@@ -489,19 +501,19 @@ const char* const upper_node_names[] = {
|
|
|
".", "g.h", "g.h"};
|
|
|
|
|
|
TEST_F(DomainTreeTest, getUpperNode) {
|
|
|
- DomainTreeNodeChain<int> node_path;
|
|
|
- const DomainTreeNode<int>* node = NULL;
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ TestDomainTreeNodeChain node_path;
|
|
|
+ const TestDomainTreeNode* node = NULL;
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
rbtree_expose_empty_node.find(Name(names[0]),
|
|
|
&node,
|
|
|
node_path));
|
|
|
for (int i = 0; i < name_count; ++i) {
|
|
|
EXPECT_NE(static_cast<void*>(NULL), node);
|
|
|
|
|
|
- const DomainTreeNode<int>* upper_node = node->getUpperNode();
|
|
|
+ const TestDomainTreeNode* upper_node = node->getUpperNode();
|
|
|
if (upper_node_names[i] != NULL) {
|
|
|
- const DomainTreeNode<int>* upper_node2 = NULL;
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ const TestDomainTreeNode* upper_node2 = NULL;
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
rbtree_expose_empty_node.find(Name(upper_node_names[i]),
|
|
|
&upper_node2));
|
|
|
EXPECT_NE(static_cast<void*>(NULL), upper_node2);
|
|
@@ -518,9 +530,9 @@ TEST_F(DomainTreeTest, getUpperNode) {
|
|
|
}
|
|
|
|
|
|
TEST_F(DomainTreeTest, nextNode) {
|
|
|
- DomainTreeNodeChain<int> node_path;
|
|
|
- const DomainTreeNode<int>* node = NULL;
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ TestDomainTreeNodeChain node_path;
|
|
|
+ const TestDomainTreeNode* node = NULL;
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
rbtree.find(Name(names[0]), &node, node_path));
|
|
|
for (int i = 0; i < name_count; ++i) {
|
|
|
EXPECT_NE(static_cast<void*>(NULL), node);
|
|
@@ -546,8 +558,8 @@ TEST_F(DomainTreeTest, nextNode) {
|
|
|
// (true is for finds that return no match, false for the ones that return
|
|
|
// match)
|
|
|
void
|
|
|
-previousWalk(DomainTree<int>& rbtree, const DomainTreeNode<int>* node,
|
|
|
- DomainTreeNodeChain<int>& node_path, size_t chain_length,
|
|
|
+previousWalk(TestDomainTree& rbtree, const TestDomainTreeNode* node,
|
|
|
+ TestDomainTreeNodeChain& node_path, size_t chain_length,
|
|
|
bool skip_first)
|
|
|
{
|
|
|
if (skip_first) {
|
|
@@ -564,9 +576,9 @@ previousWalk(DomainTree<int>& rbtree, const DomainTreeNode<int>* node,
|
|
|
//
|
|
|
// The "empty" nodes can not be found
|
|
|
if (node->getData()) {
|
|
|
- const DomainTreeNode<int>* node2(NULL);
|
|
|
- DomainTreeNodeChain<int> node_path2;
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ const TestDomainTreeNode* node2(NULL);
|
|
|
+ TestDomainTreeNodeChain node_path2;
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
rbtree.find(Name(names[i - 1]), &node2, node_path2));
|
|
|
EXPECT_EQ(node, node2);
|
|
|
}
|
|
@@ -590,13 +602,13 @@ previousWalk(DomainTree<int>& rbtree, const DomainTreeNode<int>* node,
|
|
|
// Check the previousNode
|
|
|
TEST_F(DomainTreeTest, previousNode) {
|
|
|
// First, iterate the whole tree from the end to the beginning.
|
|
|
- DomainTreeNodeChain<int> node_path;
|
|
|
+ TestDomainTreeNodeChain node_path;
|
|
|
EXPECT_THROW(rbtree.previousNode(node_path), isc::BadValue) <<
|
|
|
"Throw before a search was done on the path";
|
|
|
- const DomainTreeNode<int>* node(NULL);
|
|
|
+ const TestDomainTreeNode* node(NULL);
|
|
|
{
|
|
|
SCOPED_TRACE("Iterate through");
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
rbtree.find(Name(names[name_count - 1]), &node, node_path));
|
|
|
previousWalk(rbtree, node, node_path, name_count, false);
|
|
|
node = NULL;
|
|
@@ -606,7 +618,7 @@ TEST_F(DomainTreeTest, previousNode) {
|
|
|
{
|
|
|
SCOPED_TRACE("Iterate from the middle");
|
|
|
// Now, start somewhere in the middle, but within the real node.
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
rbtree.find(Name(names[4]), &node, node_path));
|
|
|
previousWalk(rbtree, node, node_path, 5, false);
|
|
|
node = NULL;
|
|
@@ -617,7 +629,7 @@ TEST_F(DomainTreeTest, previousNode) {
|
|
|
SCOPED_TRACE("Start at the first");
|
|
|
// If we start at the lowest (which is "a"), we get to the beginning
|
|
|
// right away.
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
rbtree.find(Name(names[0]), &node, node_path));
|
|
|
EXPECT_NE(static_cast<void*>(NULL), node);
|
|
|
node = rbtree.previousNode(node_path);
|
|
@@ -631,7 +643,7 @@ TEST_F(DomainTreeTest, previousNode) {
|
|
|
SCOPED_TRACE("Start before the first");
|
|
|
// If we start before the lowest (. < 0. < a.), we should not get a
|
|
|
// node. Its previous node should be the root.
|
|
|
- EXPECT_EQ(DomainTree<int>::NOTFOUND,
|
|
|
+ EXPECT_EQ(TestDomainTree::NOTFOUND,
|
|
|
rbtree.find<void*>(Name("0"), &node, node_path, NULL, NULL));
|
|
|
EXPECT_EQ(static_cast<void*>(NULL), node);
|
|
|
node = rbtree.previousNode(node_path);
|
|
@@ -643,7 +655,7 @@ TEST_F(DomainTreeTest, previousNode) {
|
|
|
|
|
|
{
|
|
|
SCOPED_TRACE("Start after the last");
|
|
|
- EXPECT_EQ(DomainTree<int>::NOTFOUND,
|
|
|
+ EXPECT_EQ(TestDomainTree::NOTFOUND,
|
|
|
rbtree.find(Name("z"), &node, node_path));
|
|
|
previousWalk(rbtree, node, node_path, name_count, true);
|
|
|
node = NULL;
|
|
@@ -655,7 +667,7 @@ TEST_F(DomainTreeTest, previousNode) {
|
|
|
// We exit a leaf by going down. We should start by the one
|
|
|
// we exited - 'c' (actually, we should get it by the find, as partial
|
|
|
// match).
|
|
|
- EXPECT_EQ(DomainTree<int>::PARTIALMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH,
|
|
|
rbtree.find(Name("b.c"), &node, node_path));
|
|
|
previousWalk(rbtree, node, node_path, 3, false);
|
|
|
node = NULL;
|
|
@@ -669,7 +681,7 @@ TEST_F(DomainTreeTest, previousNode) {
|
|
|
|
|
|
// The d.e.f is empty node, so it is hidden by find. Therefore NOTFOUND
|
|
|
// and not PARTIALMATCH.
|
|
|
- EXPECT_EQ(DomainTree<int>::NOTFOUND,
|
|
|
+ EXPECT_EQ(TestDomainTree::NOTFOUND,
|
|
|
rbtree.find(Name("xy.d.e.f"), &node, node_path));
|
|
|
previousWalk(rbtree, node, node_path, 5, true);
|
|
|
node = NULL;
|
|
@@ -683,7 +695,7 @@ TEST_F(DomainTreeTest, previousNode) {
|
|
|
|
|
|
// The d.e.f is empty node, so it is hidden by find. Therefore NOTFOUND
|
|
|
// and not PARTIALMATCH.
|
|
|
- EXPECT_EQ(DomainTree<int>::NOTFOUND,
|
|
|
+ EXPECT_EQ(TestDomainTree::NOTFOUND,
|
|
|
rbtree.find(Name("yz.d.e.f"), &node, node_path));
|
|
|
previousWalk(rbtree, node, node_path, 9, true);
|
|
|
node = NULL;
|
|
@@ -697,7 +709,7 @@ TEST_F(DomainTreeTest, previousNode) {
|
|
|
|
|
|
// 'g.h' is an empty node, so we get a NOTFOUND and not
|
|
|
// PARTIALMATCH.
|
|
|
- EXPECT_EQ(DomainTree<int>::NOTFOUND,
|
|
|
+ EXPECT_EQ(TestDomainTree::NOTFOUND,
|
|
|
rbtree.find(Name("x.h"), &node, node_path));
|
|
|
// 'g.h' is the COMMONANCESTOR.
|
|
|
EXPECT_EQ(node_path.getLastComparedNode()->getName(), Name("g.h"));
|
|
@@ -716,7 +728,7 @@ TEST_F(DomainTreeTest, previousNode) {
|
|
|
SCOPED_TRACE("Start inside a wrong node");
|
|
|
// The d.e.f is a single node, but we want only part of it. We
|
|
|
// should start iterating before it.
|
|
|
- EXPECT_EQ(DomainTree<int>::NOTFOUND,
|
|
|
+ EXPECT_EQ(TestDomainTree::NOTFOUND,
|
|
|
rbtree.find(Name("e.f"), &node, node_path));
|
|
|
previousWalk(rbtree, node, node_path, 3, true);
|
|
|
node = NULL;
|
|
@@ -726,9 +738,9 @@ TEST_F(DomainTreeTest, previousNode) {
|
|
|
{
|
|
|
SCOPED_TRACE("Lookup in empty tree");
|
|
|
// Just check it doesn't crash, etc.
|
|
|
- TreeHolder tree_holder(mem_sgmt_, DomainTree<int>::create(mem_sgmt_));
|
|
|
- DomainTree<int>& empty_tree(*tree_holder.get());
|
|
|
- EXPECT_EQ(DomainTree<int>::NOTFOUND,
|
|
|
+ TreeHolder tree_holder(mem_sgmt_, TestDomainTree::create(mem_sgmt_));
|
|
|
+ TestDomainTree& empty_tree(*tree_holder.get());
|
|
|
+ EXPECT_EQ(TestDomainTree::NOTFOUND,
|
|
|
empty_tree.find(Name("x"), &node, node_path));
|
|
|
EXPECT_EQ(static_cast<void*>(NULL), node);
|
|
|
EXPECT_EQ(static_cast<void*>(NULL),
|
|
@@ -740,13 +752,13 @@ TEST_F(DomainTreeTest, previousNode) {
|
|
|
|
|
|
TEST_F(DomainTreeTest, nextNodeError) {
|
|
|
// Empty chain for nextNode() is invalid.
|
|
|
- DomainTreeNodeChain<int> chain;
|
|
|
+ TestDomainTreeNodeChain chain;
|
|
|
EXPECT_THROW(rbtree.nextNode(chain), BadValue);
|
|
|
}
|
|
|
|
|
|
// A helper function for getLastComparedNode() below.
|
|
|
void
|
|
|
-comparisonChecks(const DomainTreeNodeChain<int>& chain,
|
|
|
+comparisonChecks(const TestDomainTreeNodeChain& chain,
|
|
|
int expected_order, int expected_common_labels,
|
|
|
NameComparisonResult::NameRelation expected_reln)
|
|
|
{
|
|
@@ -764,24 +776,24 @@ comparisonChecks(const DomainTreeNodeChain<int>& chain,
|
|
|
}
|
|
|
|
|
|
TEST_F(DomainTreeTest, getLastComparedNode) {
|
|
|
- DomainTree<int>& tree = rbtree_expose_empty_node; // use the "empty OK" mode
|
|
|
- DomainTreeNodeChain<int> chain;
|
|
|
+ TestDomainTree& tree = rbtree_expose_empty_node; // use the "empty OK" mode
|
|
|
+ TestDomainTreeNodeChain chain;
|
|
|
|
|
|
// initially there should be no 'last compared'.
|
|
|
EXPECT_EQ(static_cast<void*>(NULL), chain.getLastComparedNode());
|
|
|
|
|
|
// A search for an empty tree should result in no 'last compared', too.
|
|
|
- TreeHolder tree_holder(mem_sgmt_, DomainTree<int>::create(mem_sgmt_));
|
|
|
- DomainTree<int>& empty_tree(*tree_holder.get());
|
|
|
- EXPECT_EQ(DomainTree<int>::NOTFOUND,
|
|
|
+ TreeHolder tree_holder(mem_sgmt_, TestDomainTree::create(mem_sgmt_));
|
|
|
+ TestDomainTree& empty_tree(*tree_holder.get());
|
|
|
+ EXPECT_EQ(TestDomainTree::NOTFOUND,
|
|
|
empty_tree.find(Name("a"), &crbtnode, chain));
|
|
|
EXPECT_EQ(static_cast<void*>(NULL), chain.getLastComparedNode());
|
|
|
chain.clear();
|
|
|
|
|
|
- const DomainTreeNode<int>* expected_node = NULL;
|
|
|
+ const TestDomainTreeNode* expected_node = NULL;
|
|
|
|
|
|
// Exact match case. The returned node should be last compared.
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
tree.find(Name("x.d.e.f"), &expected_node, chain));
|
|
|
EXPECT_EQ(expected_node, chain.getLastComparedNode());
|
|
|
// 1 = # labels of "x" (note: excluding ".")
|
|
@@ -790,9 +802,9 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
|
|
|
|
|
|
// Partial match, search stopped at the matching node, which should be
|
|
|
// the last compared node.
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
tree.find(Name("k.g.h"), &expected_node));
|
|
|
- EXPECT_EQ(DomainTree<int>::PARTIALMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH,
|
|
|
tree.find(Name("x.k.g.h"), &crbtnode, chain));
|
|
|
EXPECT_EQ(expected_node, chain.getLastComparedNode());
|
|
|
// k.g.h < x.k.g.h, 1 = # labels of "k"
|
|
@@ -801,9 +813,9 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
|
|
|
|
|
|
// Partial match, search stopped in the subtree below the matching node
|
|
|
// after following a left branch.
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
tree.find(Name("x.d.e.f"), &expected_node));
|
|
|
- EXPECT_EQ(DomainTree<int>::PARTIALMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH,
|
|
|
tree.find(Name("a.d.e.f"), &crbtnode, chain));
|
|
|
EXPECT_EQ(expected_node, chain.getLastComparedNode());
|
|
|
// a < x, no common labels
|
|
@@ -812,9 +824,9 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
|
|
|
|
|
|
// Partial match, search stopped in the subtree below the matching node
|
|
|
// after following a right branch.
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
tree.find(Name("z.d.e.f"), &expected_node));
|
|
|
- EXPECT_EQ(DomainTree<int>::PARTIALMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH,
|
|
|
tree.find(Name("zz.d.e.f"), &crbtnode, chain));
|
|
|
EXPECT_EQ(expected_node, chain.getLastComparedNode());
|
|
|
// zz > z, no common label
|
|
@@ -823,9 +835,9 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
|
|
|
|
|
|
// Partial match, search stopped at a node for a super domain of the
|
|
|
// search name in the subtree below the matching node.
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
tree.find(Name("w.y.d.e.f"), &expected_node));
|
|
|
- EXPECT_EQ(DomainTree<int>::PARTIALMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH,
|
|
|
tree.find(Name("y.d.e.f"), &crbtnode, chain));
|
|
|
EXPECT_EQ(expected_node, chain.getLastComparedNode());
|
|
|
// y < w.y, 1 = # labels of "y"
|
|
@@ -835,7 +847,7 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
|
|
|
// Partial match, search stopped at a node that share a common ancestor
|
|
|
// with the search name in the subtree below the matching node.
|
|
|
// (the expected node is the same as the previous case)
|
|
|
- EXPECT_EQ(DomainTree<int>::PARTIALMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH,
|
|
|
tree.find(Name("z.y.d.e.f"), &crbtnode, chain));
|
|
|
EXPECT_EQ(expected_node, chain.getLastComparedNode());
|
|
|
// z.y > w.y, 1 = # labels of "y"
|
|
@@ -844,8 +856,8 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
|
|
|
|
|
|
// Search stops in the highest level (under ".") after following a left
|
|
|
// branch. (find() still returns PARTIALMATCH due to the top level ".")
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH, tree.find(Name("c"), &expected_node));
|
|
|
- EXPECT_EQ(DomainTree<int>::PARTIALMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH, tree.find(Name("c"), &expected_node));
|
|
|
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH,
|
|
|
tree.find(Name("bb"), &crbtnode, chain));
|
|
|
EXPECT_EQ(expected_node, chain.getLastComparedNode());
|
|
|
// bb < c, no common label
|
|
@@ -854,7 +866,7 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
|
|
|
|
|
|
// Search stops in the highest level (under ".") after following a right
|
|
|
// branch. (the expected node is the same as the previous case)
|
|
|
- EXPECT_EQ(DomainTree<int>::PARTIALMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH,
|
|
|
tree.find(Name("d"), &crbtnode, chain));
|
|
|
EXPECT_EQ(expected_node, chain.getLastComparedNode());
|
|
|
// d > c, no common label
|
|
@@ -923,9 +935,9 @@ TEST_F(DomainTreeTest, swap) {
|
|
|
size_t count1(rbtree.getNodeCount());
|
|
|
|
|
|
// Create second one and store state
|
|
|
- TreeHolder tree_holder(mem_sgmt_, DomainTree<int>::create(mem_sgmt_));
|
|
|
- DomainTree<int>& tree2(*tree_holder.get());
|
|
|
- DomainTreeNode<int>* node;
|
|
|
+ TreeHolder tree_holder(mem_sgmt_, TestDomainTree::create(mem_sgmt_));
|
|
|
+ TestDomainTree& tree2(*tree_holder.get());
|
|
|
+ TestDomainTreeNode* node;
|
|
|
tree2.insert(mem_sgmt_, Name("second"), &node);
|
|
|
std::ostringstream str2;
|
|
|
tree2.dumpTree(str2);
|
|
@@ -950,41 +962,41 @@ TEST_F(DomainTreeTest, swap) {
|
|
|
// any domain names should be considered a subdomain of it), so it makes
|
|
|
// sense to test cases with the root zone explicitly.
|
|
|
TEST_F(DomainTreeTest, root) {
|
|
|
- TreeHolder tree_holder(mem_sgmt_, DomainTree<int>::create(mem_sgmt_));
|
|
|
- DomainTree<int>& root(*tree_holder.get());
|
|
|
+ TreeHolder tree_holder(mem_sgmt_, TestDomainTree::create(mem_sgmt_));
|
|
|
+ TestDomainTree& root(*tree_holder.get());
|
|
|
root.insert(mem_sgmt_, Name::ROOT_NAME(), &rbtnode);
|
|
|
- rbtnode->setData(DomainTreeNode<int>::NodeDataPtr(new int(1)));
|
|
|
+ rbtnode->setData(new int(1));
|
|
|
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
root.find(Name::ROOT_NAME(), &crbtnode));
|
|
|
EXPECT_EQ(rbtnode, crbtnode);
|
|
|
- EXPECT_EQ(DomainTree<int>::PARTIALMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH,
|
|
|
root.find(Name("example.com"), &crbtnode));
|
|
|
EXPECT_EQ(rbtnode, crbtnode);
|
|
|
|
|
|
// Insert a new name that better matches the query name. find() should
|
|
|
// find the better one.
|
|
|
root.insert(mem_sgmt_, Name("com"), &rbtnode);
|
|
|
- rbtnode->setData(DomainTreeNode<int>::NodeDataPtr(new int(2)));
|
|
|
- EXPECT_EQ(DomainTree<int>::PARTIALMATCH,
|
|
|
+ rbtnode->setData(new int(2));
|
|
|
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH,
|
|
|
root.find(Name("example.com"), &crbtnode));
|
|
|
EXPECT_EQ(rbtnode, crbtnode);
|
|
|
|
|
|
// Perform the same tests for the tree that allows matching against empty
|
|
|
// nodes.
|
|
|
TreeHolder tree_holder_emptyok(mem_sgmt_,
|
|
|
- DomainTree<int>::create(mem_sgmt_, true));
|
|
|
- DomainTree<int>& root_emptyok(*tree_holder_emptyok.get());
|
|
|
+ TestDomainTree::create(mem_sgmt_, true));
|
|
|
+ TestDomainTree& root_emptyok(*tree_holder_emptyok.get());
|
|
|
root_emptyok.insert(mem_sgmt_, Name::ROOT_NAME(), &rbtnode);
|
|
|
- EXPECT_EQ(DomainTree<int>::EXACTMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::EXACTMATCH,
|
|
|
root_emptyok.find(Name::ROOT_NAME(), &crbtnode));
|
|
|
EXPECT_EQ(rbtnode, crbtnode);
|
|
|
- EXPECT_EQ(DomainTree<int>::PARTIALMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH,
|
|
|
root_emptyok.find(Name("example.com"), &crbtnode));
|
|
|
EXPECT_EQ(rbtnode, crbtnode);
|
|
|
|
|
|
root.insert(mem_sgmt_, Name("com"), &rbtnode);
|
|
|
- EXPECT_EQ(DomainTree<int>::PARTIALMATCH,
|
|
|
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH,
|
|
|
root.find(Name("example.com"), &crbtnode));
|
|
|
EXPECT_EQ(rbtnode, crbtnode);
|
|
|
}
|