BIND 10 trac2292, updated. 915576b6aa27d020faadf7fbfc4e4d9bb1df129e [2292] Remove unused template parameters
BIND 10 source code commits
bind10-changes at lists.isc.org
Sun Oct 7 14:51:27 UTC 2012
The branch, trac2292 has been updated
via 915576b6aa27d020faadf7fbfc4e4d9bb1df129e (commit)
via e1b4bf1cb50160c436f2e5440fd774680b91b7a2 (commit)
via 76243c3ccd7a30484da8478f7457e18fce485492 (commit)
from 5c74085e2f4c16655e77e1bcbc308d4fb0a694f8 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 915576b6aa27d020faadf7fbfc4e4d9bb1df129e
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Sun Oct 7 16:50:50 2012 +0200
[2292] Remove unused template parameters
The domain tree no longer supports the mutable find versions, so we
don't need the template parameters allowing for them.
commit e1b4bf1cb50160c436f2e5440fd774680b91b7a2
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Sun Oct 7 16:38:23 2012 +0200
[2292] Remove mutable find methods
They are currently used in test code only (so we'll need to update the
tests to compile). The real code seams clean now.
commit 76243c3ccd7a30484da8478f7457e18fce485492
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Sun Oct 7 16:13:56 2012 +0200
[2292] Remove the setZoneData method
Currently, the content of zone is passed to the addZone method. No way
to change it later, but the addZone overwrites the old value if called
again.
This should hopefully allow for removal of mutable find methods from the
tree.
-----------------------------------------------------------------------
Summary of changes:
src/lib/datasrc/memory/domaintree.h | 105 +++-----------------
src/lib/datasrc/memory/memory_client.cc | 35 +------
src/lib/datasrc/memory/memory_client.h | 29 ------
src/lib/datasrc/memory/zone_table.cc | 43 ++------
src/lib/datasrc/memory/zone_table.h | 58 ++++-------
.../datasrc/tests/memory/zone_table_unittest.cc | 67 +++++++++----
6 files changed, 97 insertions(+), 240 deletions(-)
-----------------------------------------------------------------------
diff --git a/src/lib/datasrc/memory/domaintree.h b/src/lib/datasrc/memory/domaintree.h
index e54d8ea..5101c65 100644
--- a/src/lib/datasrc/memory/domaintree.h
+++ b/src/lib/datasrc/memory/domaintree.h
@@ -684,7 +684,7 @@ DomainTreeNode<T>::predecessor() const {
/// DomainTree.
/// This is the reason why manipulation methods such as \c push() and \c pop()
/// are private (and not shown in the doxygen document).
-template <typename T, typename NodeType = const DomainTreeNode<T> >
+template <typename T>
class DomainTreeNodeChain {
/// DomainTreeNodeChain is initialized by DomainTree, only DomainTree has
/// knowledge to manipulate it.
@@ -817,7 +817,7 @@ private:
/// root node of DomainTree
///
/// \exception None
- NodeType* top() const {
+ const DomainTreeNode<T>* top() const {
assert(!isEmpty());
return (nodes_[level_count_ - 1]);
}
@@ -840,7 +840,7 @@ private:
/// otherwise the node should be the root node of DomainTree.
///
/// \exception None
- void push(NodeType* node) {
+ void push(const DomainTreeNode<T>* node) {
assert(level_count_ < RBT_MAX_LEVEL);
nodes_[level_count_++] = node;
}
@@ -852,7 +852,7 @@ private:
const static int RBT_MAX_LEVEL = isc::dns::Name::MAX_LABELS;
size_t level_count_;
- NodeType* nodes_[RBT_MAX_LEVEL];
+ const DomainTreeNode<T>* nodes_[RBT_MAX_LEVEL];
const DomainTreeNode<T>* last_compared_;
isc::dns::NameComparisonResult last_comparison_;
};
@@ -1080,82 +1080,25 @@ public:
/// of it. In that case, node parameter is left intact.
//@{
- /// \brief Simple find.
+ /// \brief Simple find
///
/// Acts as described in the \ref find section.
Result find(const isc::dns::Name& name,
- DomainTreeNode<T>** node) const {
- DomainTreeNodeChain<T, DomainTreeNode<T> > node_path;
- const isc::dns::LabelSequence ls(name);
- return (find<void*, DomainTreeNode<T> >(ls, node, node_path, NULL,
- NULL));
- }
-
- /// \brief Simple find returning immutable node.
- ///
- /// Acts as described in the \ref find section, but returns immutable node
- /// pointer.
- Result find(const isc::dns::Name& name,
const DomainTreeNode<T>** node) const {
DomainTreeNodeChain<T> node_path;
- const DomainTreeNode<T> *target_node = NULL;
const isc::dns::LabelSequence ls(name);
- Result ret = (find<void*, const DomainTreeNode<T> >(ls, &target_node,
- node_path, NULL,
- NULL));
- if (ret != NOTFOUND) {
- *node = target_node;
- }
+ Result ret = (find<void*>(ls, node, node_path, NULL, NULL));
return (ret);
}
/// \brief Simple find, with node_path tracking
///
/// Acts as described in the \ref find section.
- Result find(const isc::dns::Name& name, DomainTreeNode<T>** node,
- DomainTreeNodeChain<T>& node_path) const
- {
- const isc::dns::LabelSequence ls(name);
- return (find<void*, const DomainTreeNode<T> >(ls, node, node_path,
- NULL, NULL));
- }
-
- /// \brief Simple find returning immutable node, with node_path tracking
- ///
- /// Acts as described in the \ref find section, but returns immutable node
- /// pointer.
Result find(const isc::dns::Name& name, const DomainTreeNode<T>** node,
DomainTreeNodeChain<T>& node_path) const
{
- const DomainTreeNode<T> *target_node = NULL;
const isc::dns::LabelSequence ls(name);
- Result ret = (find<void*, const DomainTreeNode<T> >(ls, &target_node,
- node_path, NULL,
- NULL));
- if (ret != NOTFOUND) {
- *node = target_node;
- }
- return (ret);
- }
-
- /// \brief Simple find returning immutable node.
- ///
- /// Acts as described in the \ref find section, but returns immutable
- /// node pointer.
- template <typename CBARG>
- Result find(const isc::dns::Name& name,
- const DomainTreeNode<T>** node,
- DomainTreeNodeChain<T>& node_path,
- bool (*callback)(const DomainTreeNode<T>&, CBARG),
- CBARG callback_arg) const
- {
- const DomainTreeNode<T>* target_node = NULL;
- const isc::dns::LabelSequence ls(name);
- Result ret = find(ls, &target_node, node_path, callback,
- callback_arg);
- if (ret != NOTFOUND) {
- *node = target_node;
- }
+ Result ret = (find<void*>(ls, node, node_path, NULL, NULL));
return (ret);
}
@@ -1233,34 +1176,12 @@ public:
///
/// \return As in the description, but in case of callback returning
/// \c true, it returns immediately with the current node.
- template <typename CBARG, typename NodeType>
- Result find(const isc::dns::LabelSequence& target_labels_orig,
- NodeType** node,
- DomainTreeNodeChain<T, NodeType>& node_path,
- bool (*callback)(const DomainTreeNode<T>&, CBARG),
- CBARG callback_arg) const;
-
- /// \brief Simple find returning immutable node.
- ///
- /// Acts as described in the \ref find section, but returns immutable
- /// node pointer.
template <typename CBARG>
- Result find(const isc::dns::LabelSequence& target_labels,
+ Result find(const isc::dns::LabelSequence& target_labels_orig,
const DomainTreeNode<T>** node,
DomainTreeNodeChain<T>& node_path,
bool (*callback)(const DomainTreeNode<T>&, CBARG),
- CBARG callback_arg) const
- {
- const DomainTreeNode<T>* target_node = NULL;
- Result ret = find<CBARG, const DomainTreeNode<T> >(target_labels,
- &target_node,
- node_path, callback,
- callback_arg);
- if (ret != NOTFOUND) {
- *node = target_node;
- }
- return (ret);
- }
+ CBARG callback_arg) const;
//@}
/// \brief return the next bigger node in DNSSEC order from a given node
@@ -1520,11 +1441,11 @@ DomainTree<T>::deleteHelper(util::MemorySegment& mem_sgmt,
}
template <typename T>
-template <typename CBARG, typename NodeType>
+template <typename CBARG>
typename DomainTree<T>::Result
DomainTree<T>::find(const isc::dns::LabelSequence& target_labels_orig,
- NodeType** target,
- DomainTreeNodeChain<T, NodeType>& node_path,
+ const DomainTreeNode<T>** target,
+ DomainTreeNodeChain<T>& node_path,
bool (*callback)(const DomainTreeNode<T>&, CBARG),
CBARG callback_arg) const
{
@@ -1534,7 +1455,7 @@ DomainTree<T>::find(const isc::dns::LabelSequence& target_labels_orig,
" and label sequence");
}
- NodeType* node;
+ const DomainTreeNode<T>* node;
if (!node_path.isEmpty()) {
// Get the top node in the node chain
diff --git a/src/lib/datasrc/memory/memory_client.cc b/src/lib/datasrc/memory/memory_client.cc
index 5f6f510..de953ca 100644
--- a/src/lib/datasrc/memory/memory_client.cc
+++ b/src/lib/datasrc/memory/memory_client.cc
@@ -630,22 +630,15 @@ InMemoryClient::InMemoryClientImpl::load(
std::string* tstr = node->setData(new std::string(filename));
delete tstr;
- ZoneTable::AddResult result(zone_table_->addZone(mem_sgmt_, rrclass_,
- zone_name));
- if (result.code == result::SUCCESS) {
+ result::Result result(zone_table_->addZone(mem_sgmt_, rrclass_,
+ zone_name, holder));
+ if (result == result::SUCCESS) {
// Only increment the zone count if the zone doesn't already
// exist.
++zone_count_;
}
- ZoneTable::FindResult fr(zone_table_->setZoneData(zone_name,
- holder.release()));
- assert(fr.code == result::SUCCESS);
- if (fr.zone_data != NULL) {
- ZoneData::destroy(mem_sgmt_, fr.zone_data, rrclass_);
- }
-
- return (result.code);
+ return (result);
}
namespace {
@@ -732,7 +725,7 @@ InMemoryClient::load(const isc::dns::Name& zone_name,
const std::string
InMemoryClient::getFileName(const isc::dns::Name& zone_name) const {
- FileNameNode* node(NULL);
+ const FileNameNode* node(NULL);
FileNameTree::Result result = impl_->file_name_tree_->find(zone_name,
&node);
if (result == FileNameTree::EXACTMATCH) {
@@ -742,24 +735,6 @@ InMemoryClient::getFileName(const isc::dns::Name& zone_name) const {
}
}
-result::Result
-InMemoryClient::add(const isc::dns::Name& zone_name,
- const ConstRRsetPtr& rrset)
-{
- const ZoneTable::FindResult result =
- impl_->zone_table_->findZone(zone_name);
- if (result.code != result::SUCCESS) {
- isc_throw(DataSourceError, "No such zone: " + zone_name.toText());
- }
-
- const ConstRRsetPtr sig_rrset =
- rrset ? rrset->getRRsig() : ConstRRsetPtr();
- impl_->add(rrset, sig_rrset, zone_name, *result.zone_data);
-
- // add() doesn't allow duplicate add, so we always return SUCCESS.
- return (result::SUCCESS);
-}
-
namespace {
class MemoryIterator : public ZoneIterator {
diff --git a/src/lib/datasrc/memory/memory_client.h b/src/lib/datasrc/memory/memory_client.h
index 330d62e..c37ad53 100644
--- a/src/lib/datasrc/memory/memory_client.h
+++ b/src/lib/datasrc/memory/memory_client.h
@@ -139,35 +139,6 @@ public:
/// zone from a file before.
const std::string getFileName(const isc::dns::Name& zone_name) const;
- /// \brief Inserts an rrset into the zone.
- ///
- /// It puts another RRset into the zone.
- ///
- /// In the current implementation, this method doesn't allow an existing
- /// RRset to be updated or overridden. So the caller must make sure that
- /// all RRs of the same type and name must be given in the form of a
- /// single RRset. The current implementation will also require that
- /// when an RRSIG is added, the RRset to be covered has already been
- /// added. These restrictions are probably too strict when this data
- /// source accepts various forms of input, so they should be revisited
- /// later.
- ///
- /// Except for NullRRset and OutOfZone, this method does not guarantee
- /// strong exception safety (it is currently not needed, if it is needed
- /// in future, it should be implemented).
- ///
- /// \throw NullRRset \c rrset is a NULL pointer.
- /// \throw OutOfZone The owner name of \c rrset is outside of the
- /// origin of the zone.
- /// \throw AddError Other general errors.
- /// \throw Others This method might throw standard allocation exceptions.
- ///
- /// \param rrset The set to add.
- /// \return SUCCESS or EXIST (if an rrset for given name and type already
- /// exists).
- result::Result add(const isc::dns::Name& zone_name,
- const isc::dns::ConstRRsetPtr& rrset);
-
/// \brief RRset is NULL exception.
///
/// This is thrown if the provided RRset parameter is NULL.
diff --git a/src/lib/datasrc/memory/zone_table.cc b/src/lib/datasrc/memory/zone_table.cc
index a74a61d..0e6ed3c 100644
--- a/src/lib/datasrc/memory/zone_table.cc
+++ b/src/lib/datasrc/memory/zone_table.cc
@@ -67,19 +67,11 @@ ZoneTable::destroy(util::MemorySegment& mem_sgmt, ZoneTable* ztable,
mem_sgmt.deallocate(ztable, sizeof(ZoneTable));
}
-ZoneTable::AddResult
+result::Result
ZoneTable::addZone(util::MemorySegment& mem_sgmt, RRClass zone_class,
- const Name& zone_name)
+ const Name& zone_name,
+ SegmentObjectHolder<ZoneData, RRClass>& content)
{
- // Create a new ZoneData instance first. If the specified name already
- // exists in the table, the new data will soon be destroyed, but we want
- // to make sure if this allocation fails the tree won't be changed to
- // provide as strong guarantee as possible. In practice, we generally
- // expect the caller tries to add a zone only when it's a new one, so
- // this should be a minor concern.
- SegmentObjectHolder<ZoneData, RRClass> holder(
- mem_sgmt, ZoneData::create(mem_sgmt, zone_name), zone_class);
-
// Get the node where we put the zone
ZoneTableNode* node(NULL);
switch (zones_->insert(mem_sgmt, zone_name, &node)) {
@@ -94,18 +86,19 @@ ZoneTable::addZone(util::MemorySegment& mem_sgmt, RRClass zone_class,
// Can Not Happen
assert(node != NULL);
- // Is it empty? We either just created it or it might be nonterminal
- if (node->isEmpty()) {
- node->setData(holder.get());
- return (AddResult(result::SUCCESS, holder.release()));
- } else { // There's something there already
- return (AddResult(result::EXIST, node->getData()));
+ // We can release now, setData never throws
+ ZoneData* old = node->setData(content.release());
+ if (old != NULL) {
+ ZoneData::destroy(mem_sgmt, old, zone_class);
+ return (result::EXIST);
+ } else {
+ return (result::SUCCESS);
}
}
ZoneTable::FindResult
ZoneTable::findZone(const Name& name) const {
- ZoneTableNode* node(NULL);
+ const ZoneTableNode* node(NULL);
result::Result my_result;
// Translate the return codes
@@ -132,20 +125,6 @@ ZoneTable::findZone(const Name& name) const {
return (FindResult(my_result, node->getData()));
}
-ZoneTable::FindResult
-ZoneTable::setZoneData(const Name& name, ZoneData* data)
-{
- ZoneTableNode* node(NULL);
-
- ZoneTableTree::Result result(zones_->find(name, &node));
-
- if (result != ZoneTableTree::EXACTMATCH) {
- return (FindResult(result::NOTFOUND, NULL));
- } else {
- return (FindResult(result::SUCCESS, node->setData(data)));
- }
-}
-
} // end of namespace memory
} // end of namespace datasrc
} // end of namespace isc
diff --git a/src/lib/datasrc/memory/zone_table.h b/src/lib/datasrc/memory/zone_table.h
index 8ad6213..4f309b7 100644
--- a/src/lib/datasrc/memory/zone_table.h
+++ b/src/lib/datasrc/memory/zone_table.h
@@ -36,6 +36,10 @@ namespace memory {
// forward declaration: in this header it's mostly an opaque type.
class ZoneData;
+namespace detail {
+template<class T, class C> class SegmentObjectHolder;
+}
+
/// \brief A conceptual table of authoritative zones.
///
/// This class is actually a simple wrapper for a \c DomainTree whose data is
@@ -74,23 +78,15 @@ private:
typedef DomainTreeNode<ZoneData> ZoneTableNode;
public:
- /// \brief Result data of addZone() method.
- struct AddResult {
- AddResult(result::Result param_code, ZoneData* param_zone_data) :
- code(param_code), zone_data(param_zone_data)
- {}
- const result::Result code;
- ZoneData* const zone_data;
- };
/// \brief Result data of findZone() method.
struct FindResult {
FindResult(result::Result param_code,
- ZoneData* param_zone_data) :
+ const ZoneData* param_zone_data) :
code(param_code), zone_data(param_zone_data)
{}
const result::Result code;
- ZoneData* const zone_data;
+ const ZoneData* const zone_data;
};
private:
@@ -140,30 +136,28 @@ public:
/// Add a new zone to the \c ZoneTable.
///
- /// This method creates a new \c ZoneData for the given zone name and
- /// holds it in the internal table. The newly created zone data will be
- /// returned via the \c zone_data member of the return value. If the given
- /// zone name already exists in the table, a new data object won't be
- /// created; instead, the existing corresponding data will be returned.
- ///
- /// The zone table keeps the ownership of the created zone data; the
- /// caller must not try to destroy it directly. (We'll eventually
- /// add an interface to delete specific zone data from the table).
+ /// This method adds a given zone data to the internal table.
///
/// \throw std::bad_alloc Internal resource allocation fails.
///
/// \param mem_sgmt The \c MemorySegment to allocate zone data to be
- /// created. It must be the same segment that was used to create
- /// the zone table at the time of create().
+ /// created. It must be the same segment that was used to create
+ /// the zone table at the time of create().
/// \param zone_name The name of the zone to be added.
/// \param zone_class The RR class of the zone. It must be the RR class
- /// that is supposed to be associated to the zone table.
+ /// that is supposed to be associated to the zone table.
+ /// \param content This one should hold the zone content (the ZoneData).
+ /// When it is added successfully, it is released from the holder.
/// \return \c result::SUCCESS If the zone is successfully
- /// added to the zone table.
- /// \return \c result::EXIST The zone table already contains
- /// zone of the same origin.
- AddResult addZone(util::MemorySegment& mem_sgmt, dns::RRClass zone_class,
- const dns::Name& zone_name);
+ /// added to the zone table.
+ /// \return \c result::EXIST The zone table already contained
+ /// zone of the same origin. The old data is released and replaced
+ /// by the new one.
+ result::Result addZone(util::MemorySegment& mem_sgmt,
+ dns::RRClass zone_class,
+ const dns::Name& zone_name,
+ detail::SegmentObjectHolder<ZoneData,
+ isc::dns::RRClass>& content);
/// Find a zone that best matches the given name in the \c ZoneTable.
///
@@ -185,16 +179,6 @@ public:
/// \return A \c FindResult object enclosing the search result (see above).
FindResult findZone(const isc::dns::Name& name) const;
- /// Override the ZoneData for a node (zone) in the zone tree.
- ///
- /// \throw none
- ///
- /// \param name A domain name for which the zone data is set.
- /// \param data The new zone data to set.
- /// \return A \c FindResult object containing the old data if the
- /// zone was found.
- FindResult setZoneData(const isc::dns::Name& name, ZoneData* data);
-
private:
boost::interprocess::offset_ptr<ZoneTableTree> zones_;
};
diff --git a/src/lib/datasrc/tests/memory/zone_table_unittest.cc b/src/lib/datasrc/tests/memory/zone_table_unittest.cc
index 359df49..b9ee3d9 100644
--- a/src/lib/datasrc/tests/memory/zone_table_unittest.cc
+++ b/src/lib/datasrc/tests/memory/zone_table_unittest.cc
@@ -22,6 +22,7 @@
#include <datasrc/result.h>
#include <datasrc/memory/zone_data.h>
#include <datasrc/memory/zone_table.h>
+#include <datasrc/memory/segment_object_holder.h>
#include <gtest/gtest.h>
@@ -30,6 +31,7 @@
using namespace isc::dns;
using namespace isc::datasrc;
using namespace isc::datasrc::memory;
+using namespace isc::datasrc::memory::detail;
namespace {
// Memory segment specified for tests. It normally behaves like a "local"
@@ -87,46 +89,69 @@ TEST_F(ZoneTableTest, create) {
}
TEST_F(ZoneTableTest, addZone) {
+ SegmentObjectHolder<ZoneData, RRClass> holder1(
+ mem_sgmt_, ZoneData::create(mem_sgmt_, zname1), zclass_);
// Normal successful case.
- const ZoneTable::AddResult result1 =
- zone_table->addZone(mem_sgmt_, zclass_, zname1);
- EXPECT_EQ(result::SUCCESS, result1.code);
+ EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zclass_,
+ zname1, holder1));
+ // It got released by it
+ EXPECT_EQ(NULL, holder1.get());
// Duplicate add doesn't replace the existing data.
+ SegmentObjectHolder<ZoneData, RRClass> holder2(
+ mem_sgmt_, ZoneData::create(mem_sgmt_, zname1), zclass_);
EXPECT_EQ(result::EXIST, zone_table->addZone(mem_sgmt_, zclass_,
- zname1).code);
- EXPECT_EQ(result1.zone_data,
- zone_table->addZone(mem_sgmt_, zclass_, zname1).zone_data);
+ zname1, holder2));
+ // It releases this one even when we replace the old zone
+ EXPECT_EQ(NULL, holder2.get());
+
+ SegmentObjectHolder<ZoneData, RRClass> holder3(
+ mem_sgmt_, ZoneData::create(mem_sgmt_, Name("EXAMPLE.COM")),
+ zclass_);
// names are compared in a case insensitive manner.
EXPECT_EQ(result::EXIST, zone_table->addZone(mem_sgmt_, zclass_,
- Name("EXAMPLE.COM")).code);
+ Name("EXAMPLE.COM"),
+ holder3));
// Add some more different ones. Should just succeed.
+ SegmentObjectHolder<ZoneData, RRClass> holder4(
+ mem_sgmt_, ZoneData::create(mem_sgmt_, zname2), zclass_);
EXPECT_EQ(result::SUCCESS,
- zone_table->addZone(mem_sgmt_, zclass_, zname2).code);
+ zone_table->addZone(mem_sgmt_, zclass_, zname2, holder4));
+ SegmentObjectHolder<ZoneData, RRClass> holder5(
+ mem_sgmt_, ZoneData::create(mem_sgmt_, zname3), zclass_);
EXPECT_EQ(result::SUCCESS,
- zone_table->addZone(mem_sgmt_, zclass_, zname3).code);
+ zone_table->addZone(mem_sgmt_, zclass_, zname3, holder5));
// Have the memory segment throw an exception in extending the internal
// tree. It still shouldn't cause memory leak (which would be detected
// in TearDown()).
- mem_sgmt_.setThrowCount(2);
- EXPECT_THROW(zone_table->addZone(mem_sgmt_, zclass_, Name("example.org")),
+ SegmentObjectHolder<ZoneData, RRClass> holder6(
+ mem_sgmt_, ZoneData::create(mem_sgmt_, Name("example.org")), zclass_);
+ mem_sgmt_.setThrowCount(1);
+ EXPECT_THROW(zone_table->addZone(mem_sgmt_, zclass_, Name("example.org"),
+ holder6),
std::bad_alloc);
}
TEST_F(ZoneTableTest, findZone) {
- const ZoneTable::AddResult add_result1 =
- zone_table->addZone(mem_sgmt_, zclass_, zname1);
- EXPECT_EQ(result::SUCCESS, add_result1.code);
+ SegmentObjectHolder<ZoneData, RRClass> holder1(
+ mem_sgmt_, ZoneData::create(mem_sgmt_, zname1), zclass_);
+ ZoneData* zone_data = holder1.get();
+ EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zclass_, zname1,
+ holder1));
+ SegmentObjectHolder<ZoneData, RRClass> holder2(
+ mem_sgmt_, ZoneData::create(mem_sgmt_, zname2), zclass_);
EXPECT_EQ(result::SUCCESS,
- zone_table->addZone(mem_sgmt_, zclass_, zname2).code);
+ zone_table->addZone(mem_sgmt_, zclass_, zname2, holder2));
+ SegmentObjectHolder<ZoneData, RRClass> holder3(
+ mem_sgmt_, ZoneData::create(mem_sgmt_, zname3), zclass_);
EXPECT_EQ(result::SUCCESS,
- zone_table->addZone(mem_sgmt_, zclass_, zname3).code);
+ zone_table->addZone(mem_sgmt_, zclass_, zname3, holder3));
const ZoneTable::FindResult find_result1 =
zone_table->findZone(Name("example.com"));
EXPECT_EQ(result::SUCCESS, find_result1.code);
- EXPECT_EQ(add_result1.zone_data, find_result1.zone_data);
+ EXPECT_EQ(zone_data, find_result1.zone_data);
EXPECT_EQ(result::NOTFOUND,
zone_table->findZone(Name("example.org")).code);
@@ -137,14 +162,16 @@ TEST_F(ZoneTableTest, findZone) {
// and the code should be PARTIALMATCH.
EXPECT_EQ(result::PARTIALMATCH,
zone_table->findZone(Name("www.example.com")).code);
- EXPECT_EQ(add_result1.zone_data,
+ EXPECT_EQ(zone_data,
zone_table->findZone(Name("www.example.com")).zone_data);
// make sure the partial match is indeed the longest match by adding
// a zone with a shorter origin and query again.
+ SegmentObjectHolder<ZoneData, RRClass> holder4(
+ mem_sgmt_, ZoneData::create(mem_sgmt_, Name("com")), zclass_);
EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zclass_,
- Name("com")).code);
- EXPECT_EQ(add_result1.zone_data,
+ Name("com"), holder4));
+ EXPECT_EQ(zone_data,
zone_table->findZone(Name("www.example.com")).zone_data);
}
}
More information about the bind10-changes
mailing list