BIND 10 master, updated. 26c61ea85a87cdc20ae9b52801b84338a4f0bbf2 [master] worked around dubious compiler behavior on const reference

BIND 10 source code commits bind10-changes at lists.isc.org
Mon Sep 3 14:12:01 UTC 2012


The branch, master has been updated
       via  26c61ea85a87cdc20ae9b52801b84338a4f0bbf2 (commit)
      from  b372a33a10fc7518f3dd76a4a94eeec1307eef46 (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 26c61ea85a87cdc20ae9b52801b84338a4f0bbf2
Author: JINMEI Tatuya <jinmei at isc.org>
Date:   Mon Sep 3 23:09:43 2012 +0900

    [master] worked around dubious compiler behavior on const reference
    
    this workaround should avoid this build error:
    http://git.bind10.isc.org/~tester/builder//BIND10/20120903130000-FreeBSD8-i386-Clang/logs/build.out

-----------------------------------------------------------------------

Summary of changes:
 .../memory/tests/treenode_rrset_unittest.cc        |  108 ++++++++++++--------
 1 file changed, 65 insertions(+), 43 deletions(-)

-----------------------------------------------------------------------
diff --git a/src/lib/datasrc/memory/tests/treenode_rrset_unittest.cc b/src/lib/datasrc/memory/tests/treenode_rrset_unittest.cc
index b95e706..41f3690 100644
--- a/src/lib/datasrc/memory/tests/treenode_rrset_unittest.cc
+++ b/src/lib/datasrc/memory/tests/treenode_rrset_unittest.cc
@@ -25,6 +25,8 @@
 
 #include <gtest/gtest.h>
 
+#include <boost/shared_ptr.hpp>
+
 #include <string>
 #include <vector>
 
@@ -150,33 +152,53 @@ checkBasicFields(const AbstractRRset& actual_rrset, const Name& expected_name,
     EXPECT_EQ(expected_sigcount, actual_rrset.getRRsigDataCount());
 }
 
+// The following two are trivial wrapper to create a shared pointer
+// version of TreeNodeRRset object in order to work around dubious
+// behavior of some C++ compiler: they reject getting a const reference to
+// a temporary non-copyable object.
+boost::shared_ptr<TreeNodeRRset>
+createRRset(const RRClass& rrclass, const ZoneNode* node,
+            const RdataSet* rdataset, bool dnssec_ok)
+{
+    return (boost::shared_ptr<TreeNodeRRset>(
+                new TreeNodeRRset(rrclass, node, rdataset, dnssec_ok)));
+}
+
+boost::shared_ptr<TreeNodeRRset>
+createRRset(const Name& realname, const RRClass& rrclass, const ZoneNode* node,
+            const RdataSet* rdataset, bool dnssec_ok)
+{
+    return (boost::shared_ptr<TreeNodeRRset>(
+                new TreeNodeRRset(realname, rrclass, node, rdataset,
+                                  dnssec_ok)));
+}
+
 TEST_F(TreeNodeRRsetTest, create) {
     // Constructed with RRSIG, and it should be visible.
-    checkBasicFields(TreeNodeRRset(rrclass_, www_node_, a_rdataset_, true),
+    checkBasicFields(*createRRset(rrclass_, www_node_, a_rdataset_, true),
                      www_name_, rrclass_, RRType::A(), 2, 1);
     // Constructed with RRSIG, and it should be invisible.
-    checkBasicFields(TreeNodeRRset(rrclass_, www_node_, a_rdataset_, false),
+    checkBasicFields(*createRRset(rrclass_, www_node_, a_rdataset_, false),
                      www_name_, rrclass_, RRType::A(), 2, 0);
     // Constructed without RRSIG, and it would be visible (but of course won't)
-    checkBasicFields(TreeNodeRRset(rrclass_, origin_node_, ns_rdataset_, true),
+    checkBasicFields(*createRRset(rrclass_, origin_node_, ns_rdataset_, true),
                      origin_name_, rrclass_, RRType::NS(), 1, 0);
     // Constructed without RRSIG, and it should be visible
-    checkBasicFields(TreeNodeRRset(rrclass_, origin_node_, ns_rdataset_,
-                                   false),
+    checkBasicFields(*createRRset(rrclass_, origin_node_, ns_rdataset_, false),
                      origin_name_, rrclass_, RRType::NS(), 1, 0);
     // RRSIG-only case (note the RRset's type is covered type)
-    checkBasicFields(TreeNodeRRset(rrclass_, www_node_, rrsig_only_rdataset_,
-                                   true),
+    checkBasicFields(*createRRset(rrclass_, www_node_, rrsig_only_rdataset_,
+                                  true),
                      www_name_, rrclass_, RRType::TXT(), 0, 1);
     // RRSIG-only case (note the RRset's type is covered type), but it's
     // invisible
-    checkBasicFields(TreeNodeRRset(rrclass_, www_node_, rrsig_only_rdataset_,
-                                   false),
+    checkBasicFields(*createRRset(rrclass_, www_node_, rrsig_only_rdataset_,
+                                  false),
                      www_name_, rrclass_, RRType::TXT(), 0, 0);
     // Wildcard substitution
-    checkBasicFields(TreeNodeRRset(match_name_, rrclass_,
-                                   wildcard_node_, wildcard_rdataset_,
-                                   true),
+    checkBasicFields(*createRRset(match_name_, rrclass_,
+                                  wildcard_node_, wildcard_rdataset_,
+                                  true),
                      match_name_, rrclass_, RRType::A(), 2, 1);
 }
 
@@ -307,8 +329,8 @@ TEST_F(TreeNodeRRsetTest, toWire) {
     {
         SCOPED_TRACE("wildcard with RRSIG");
         checkToWireResult(expected_renderer, actual_renderer,
-                          TreeNodeRRset(match_name_, rrclass_, wildcard_node_,
-                                        wildcard_rdataset_, true),
+                          *createRRset(match_name_, rrclass_, wildcard_node_,
+                                       wildcard_rdataset_, true),
                           origin_name_, wildmatch_rrset_,
                           wildmatch_rrsig_rrset_, true);
     }
@@ -316,8 +338,8 @@ TEST_F(TreeNodeRRsetTest, toWire) {
     {
         SCOPED_TRACE("wildcard without RRSIG");
         checkToWireResult(expected_renderer, actual_renderer,
-                          TreeNodeRRset(match_name_, rrclass_, wildcard_node_,
-                                        wildcard_rdataset_, false),
+                          *createRRset(match_name_, rrclass_, wildcard_node_,
+                                       wildcard_rdataset_, false),
                           origin_name_, wildmatch_rrset_,
                           wildmatch_rrsig_rrset_, false);
     }
@@ -355,7 +377,7 @@ TEST_F(TreeNodeRRsetTest, toWireTruncated) {
     // (type, class, TTL, rdlen, and 4-byte IPv4 address).  Then we can only
     // render just one RR, without any garbage trailing data.
     checkToWireResult(expected_renderer, actual_renderer,
-                      TreeNodeRRset(rrclass_, www_node_, a_rdataset_, true),
+                      *createRRset(rrclass_, www_node_, a_rdataset_, true),
                       name, a_rrset_, a_rrsig_rrset_, true,
                       www_name_.getLength() + 14,
                       1);   // 1 main RR, no RRSIG
@@ -363,7 +385,7 @@ TEST_F(TreeNodeRRsetTest, toWireTruncated) {
     // The first main RRs should fit in the renderer (the name will be
     // fully compressed, so its size is 2 bytes), but the RRSIG doesn't.
     checkToWireResult(expected_renderer, actual_renderer,
-                      TreeNodeRRset(rrclass_, www_node_, a_rdataset_, true),
+                      *createRRset(rrclass_, www_node_, a_rdataset_, true),
                       name, a_rrset_, a_rrsig_rrset_, true,
                       www_name_.getLength() + 14 + 2 + 14,
                       2);   // 2 main RR, no RRSIG
@@ -379,15 +401,15 @@ TEST_F(TreeNodeRRsetTest, toWireTruncated) {
     const size_t limit_len = expected_renderer.getLength();
     // Then perform the test
     checkToWireResult(expected_renderer, actual_renderer,
-                      TreeNodeRRset(rrclass_, www_node_, aaaa_rdataset_, true),
+                      *createRRset(rrclass_, www_node_, aaaa_rdataset_, true),
                       name, aaaa_rrset_, aaaa_rrsig_rrset_, true, limit_len,
                       2);   // 1 main RR, 1 RRSIG
 
     // RRSIG only case.  Render length limit being 1, so it won't fit,
     // and will cause truncation.
     checkToWireResult(expected_renderer, actual_renderer,
-                      TreeNodeRRset(rrclass_, www_node_, rrsig_only_rdataset_,
-                                    true),
+                      *createRRset(rrclass_, www_node_, rrsig_only_rdataset_,
+                                   true),
                       name, ConstRRsetPtr(), txt_rrsig_rrset_, true, 1,
                       0);   // no RR
 }
@@ -455,32 +477,32 @@ checkToText(const AbstractRRset& actual_rrset,
 
 TEST_F(TreeNodeRRsetTest, toText) {
     // Constructed with RRSIG, and it should be visible.
-    checkToText(TreeNodeRRset(rrclass_, www_node_, a_rdataset_, true),
+    checkToText(*createRRset(rrclass_, www_node_, a_rdataset_, true),
                 a_rrset_, a_rrsig_rrset_);
     // Constructed with RRSIG, and it should be invisible.
-    checkToText(TreeNodeRRset(rrclass_, www_node_, a_rdataset_, false),
+    checkToText(*createRRset(rrclass_, www_node_, a_rdataset_, false),
                 a_rrset_, ConstRRsetPtr());
     // Constructed without RRSIG, and it would be visible (but of course won't)
-    checkToText(TreeNodeRRset(rrclass_, origin_node_, ns_rdataset_, true),
+    checkToText(*createRRset(rrclass_, origin_node_, ns_rdataset_, true),
                 ns_rrset_, ConstRRsetPtr());
     // Constructed without RRSIG, and it should be visible
-    checkToText(TreeNodeRRset(rrclass_, origin_node_, ns_rdataset_, false),
+    checkToText(*createRRset(rrclass_, origin_node_, ns_rdataset_, false),
                 ns_rrset_, ConstRRsetPtr());
     // Wildcard expanded name with RRSIG
-    checkToText(TreeNodeRRset(match_name_, rrclass_, wildcard_node_,
-                              wildcard_rdataset_, true),
+    checkToText(*createRRset(match_name_, rrclass_, wildcard_node_,
+                             wildcard_rdataset_, true),
                 wildmatch_rrset_, wildmatch_rrsig_rrset_);
     // Wildcard expanded name without RRSIG
-    checkToText(TreeNodeRRset(match_name_, rrclass_, wildcard_node_,
-                              wildcard_rdataset_, false),
+    checkToText(*createRRset(match_name_, rrclass_, wildcard_node_,
+                             wildcard_rdataset_, false),
                 wildmatch_rrset_, ConstRRsetPtr());
     // RRSIG case
-    checkToText(TreeNodeRRset(rrclass_, www_node_, rrsig_only_rdataset_,
-                              true),
+    checkToText(*createRRset(rrclass_, www_node_, rrsig_only_rdataset_,
+                             true),
                 ConstRRsetPtr(), txt_rrsig_rrset_);
     // Similar to the previous case, but completely empty.
-    checkToText(TreeNodeRRset(rrclass_, www_node_, rrsig_only_rdataset_,
-                              false),
+    checkToText(*createRRset(rrclass_, www_node_, rrsig_only_rdataset_,
+                             false),
                 ConstRRsetPtr(), ConstRRsetPtr());
 }
 
@@ -488,22 +510,22 @@ TEST_F(TreeNodeRRsetTest, isSameKind) {
     const TreeNodeRRset rrset(rrclass_, www_node_, a_rdataset_, true);
 
     // Same name (node), same type (rdataset) => same kind
-    EXPECT_TRUE(rrset.isSameKind(TreeNodeRRset(rrclass_, www_node_,
-                                               a_rdataset_, true)));
+    EXPECT_TRUE(rrset.isSameKind(*createRRset(rrclass_, www_node_,
+                                              a_rdataset_, true)));
 
     // Same name (node), different type (rdataset) => not same kind
-    EXPECT_FALSE(rrset.isSameKind(TreeNodeRRset(rrclass_, www_node_,
-                                                aaaa_rdataset_, true)));
+    EXPECT_FALSE(rrset.isSameKind(*createRRset(rrclass_, www_node_,
+                                               aaaa_rdataset_, true)));
 
     // Different name, different type => not same kind
-    EXPECT_FALSE(rrset.isSameKind(TreeNodeRRset(rrclass_, origin_node_,
-                                                ns_rdataset_, true)));
+    EXPECT_FALSE(rrset.isSameKind(*createRRset(rrclass_, origin_node_,
+                                               ns_rdataset_, true)));
 
     // Different name, same type => not same kind.
     // Note: this shouldn't happen in our in-memory data source implementation,
     // but API doesn't prohibit it.
-    EXPECT_FALSE(rrset.isSameKind(TreeNodeRRset(rrclass_, origin_node_,
-                                                a_rdataset_, true)));
+    EXPECT_FALSE(rrset.isSameKind(*createRRset(rrclass_, origin_node_,
+                                               a_rdataset_, true)));
 
     // Wildcard and expanded RRset
     const TreeNodeRRset wildcard_rrset(rrclass_, wildcard_node_,
@@ -535,8 +557,8 @@ TEST_F(TreeNodeRRsetTest, isSameKind) {
     // tree node, they must belong to the same RR class.  This case is
     // a caller's bug, and the isSameKind() implementation returns the
     // "wrong" (= true) answer.
-    EXPECT_TRUE(rrset.isSameKind(TreeNodeRRset(RRClass::CH(), www_node_,
-                                               a_rdataset_, true)));
+    EXPECT_TRUE(rrset.isSameKind(*createRRset(RRClass::CH(), www_node_,
+                                              a_rdataset_, true)));
 
     // Same kind of different RRset class
     EXPECT_TRUE(rrset.isSameKind(*a_rrset_));



More information about the bind10-changes mailing list