cleanup: removed unused "Query" parameter from various data source methods

git-svn-id: svn://bind10.isc.org/svn/bind10/trunk@1316 e5f2f494-b856-4b98-b285-d166d9295462

src/lib/auth/data_source.cc

@@ -142,25 +142,25 @@ chaseCname(Query& q, QueryTaskPtr task, RRsetPtr rrset)
 
 // Perform the query specified in a QueryTask object
 static DataSrc::Result
-doQueryTask(const DataSrc* ds, const Name* zonename, Query& q, QueryTask& task,
+doQueryTask(const DataSrc* ds, const Name* zonename, QueryTask& task,
             RRsetList& target)
 {
     switch (task.op) {
     case QueryTask::AUTH_QUERY:
-        return (ds->findRRset(q, task.qname, task.qclass, task.qtype,
+        return (ds->findRRset(task.qname, task.qclass, task.qtype,
                               target, task.flags, zonename));
 
     case QueryTask::SIMPLE_QUERY:
-        return (ds->findExactRRset(q, task.qname, task.qclass, task.qtype,
+        return (ds->findExactRRset(task.qname, task.qclass, task.qtype,
                                    target, task.flags, zonename));
 
     case QueryTask::GLUE_QUERY:
     case QueryTask::NOGLUE_QUERY:
-        return (ds->findAddrs(q, task.qname, task.qclass, target,
+        return (ds->findAddrs(task.qname, task.qclass, target,
                               task.flags, zonename));
 
     case QueryTask::REF_QUERY:
-        return (ds->findReferral(q, task.qname, task.qclass, target,
+        return (ds->findReferral(task.qname, task.qclass, target,
                                  task.flags, zonename));
     }
 
@@ -191,7 +191,7 @@ refQuery(const Name& name, Query& q, const DataSrc* ds, const Name* zonename,
 {
     QueryTask newtask(name, q.qclass(), QueryTask::REF_QUERY);
 
-    if (doQueryTask(ds, zonename, q, newtask, target) != DataSrc::SUCCESS) {
+    if (doQueryTask(ds, zonename, newtask, target) != DataSrc::SUCCESS) {
         // Lookup failed
         return (false);
     }
@@ -269,7 +269,7 @@ addSOA(Query& q, const Name* zonename, const DataSrc* ds) {
 
     QueryTask newtask(*zonename, q.qclass(), RRType::SOA(),
                       QueryTask::SIMPLE_QUERY);
-    RETERR(doQueryTask(ds, zonename, q, newtask, soa));
+    RETERR(doQueryTask(ds, zonename, newtask, soa));
     if (newtask.flags != 0) {
         return (DataSrc::ERROR);
     }
@@ -287,7 +287,7 @@ addNSEC(Query& q, const QueryTaskPtr task, const Name& name,
 
     QueryTask newtask(name, task->qclass, RRType::NSEC(),
                       QueryTask::SIMPLE_QUERY); 
-    RETERR(doQueryTask(ds, &zonename, q, newtask, nsec));
+    RETERR(doQueryTask(ds, &zonename, newtask, nsec));
     if (newtask.flags == 0) {
         m.addRRset(Section::AUTHORITY(), nsec[RRType::NSEC()], true);
     }
@@ -296,11 +296,11 @@ addNSEC(Query& q, const QueryTaskPtr task, const Name& name,
 }
 
 static inline DataSrc::Result
-getNsec3(Query& q, const DataSrc* ds, const Name& zonename, string& hash, 
+getNsec3(const DataSrc* ds, const Name& zonename, string& hash, 
          RRsetPtr& target)
 {
     RRsetList rl;
-    RETERR(ds->findCoveringNSEC3(q, zonename, hash, rl));
+    RETERR(ds->findCoveringNSEC3(zonename, hash, rl));
     target = rl[RRType::NSEC3()];
     return (DataSrc::SUCCESS);
 }
@@ -312,7 +312,7 @@ getNsec3Param(Query& q, const DataSrc* ds, const Name& zonename) {
 
     QueryTask newtask(zonename, q.qclass(), RRType::NSEC3PARAM(),
                       QueryTask::SIMPLE_QUERY); 
-    result = doQueryTask(ds, &zonename, q, newtask, nsec3param);
+    result = doQueryTask(ds, &zonename, newtask, nsec3param);
     newtask.flags &= ~DataSrc::REFERRAL;
     if (result != DataSrc::SUCCESS || newtask.flags != 0) {
         return (ConstNsec3ParamPtr());
@@ -347,7 +347,7 @@ proveNX(Query& q, QueryTaskPtr task, const DataSrc* ds, const Name& zonename)
         // Attach the NSEC3 record covering the QNAME
         RRsetPtr rrset;
         string hash1(nsec3->getHash(task->qname)), hash2;
-        RETERR(getNsec3(q, ds, zonename, hash1, rrset));
+        RETERR(getNsec3(ds, zonename, hash1, rrset));
         m.addRRset(Section::AUTHORITY(), rrset, true);
 
         // If this is an NXRRSET or NOERROR/NODATA, we're done
@@ -370,7 +370,7 @@ proveNX(Query& q, QueryTaskPtr task, const DataSrc* ds, const Name& zonename)
 
             // hash2 will be overwritten with the actual hash found;
             // we don't want to use one until we find an exact match
-            RETERR(getNsec3(q, ds, zonename, hash2, rrset));
+            RETERR(getNsec3(ds, zonename, hash2, rrset));
             if (hash2 == nodehash) {
                 m.addRRset(Section::AUTHORITY(), rrset, true);
                 break;
@@ -380,14 +380,14 @@ proveNX(Query& q, QueryTaskPtr task, const DataSrc* ds, const Name& zonename)
         // Now add a covering NSEC3 for a wildcard under the
         // closest provable enclosing name
         string hash3(nsec3->getHash(Name("*").concatenate(enclosure)));
-        RETERR(getNsec3(q, ds, zonename, hash3, rrset));
+        RETERR(getNsec3(ds, zonename, hash3, rrset));
         if (hash3 != hash1 && hash3 != hash2) {
             m.addRRset(Section::AUTHORITY(), rrset, true);
         }
     } else {
         Name nsecname(task->qname);
         if ((task->flags & DataSrc::NAME_NOT_FOUND) != 0) {
-            ds->findPreviousName(q, task->qname, nsecname, &zonename);
+            ds->findPreviousName(task->qname, nsecname, &zonename);
         }
 
         RETERR(addNSEC(q, task, nsecname, zonename, ds));
@@ -432,7 +432,7 @@ tryWildcard(Query& q, QueryTaskPtr task, const DataSrc* ds,
         const Name& wname(star.concatenate(task->qname.split(i, nlen - i)));
         QueryTask newtask(wname, task->qclass, task->qtype,
                           QueryTask::SIMPLE_QUERY); 
-        result = doQueryTask(ds, zonename, q, newtask, wild);
+        result = doQueryTask(ds, zonename, newtask, wild);
         if (result == DataSrc::SUCCESS &&
             (newtask.flags == 0 || (newtask.flags & DataSrc::CNAME_FOUND))) {
             rflags = newtask.flags;
@@ -524,7 +524,7 @@ DataSrc::doQuery(Query& q)
                 continue;
             }
 
-            result = doQueryTask(datasource, zonename, q, *task, data);
+            result = doQueryTask(datasource, zonename, *task, data);
             if (result != SUCCESS) {
                 m.setRcode(Rcode::SERVFAIL());
                 return;
@@ -669,8 +669,7 @@ DataSrc::doQuery(Query& q)
 
             Name nsecname(task->qname);
             if ((task->flags & NAME_NOT_FOUND) != 0) {
-                datasource->findPreviousName(q, task->qname, nsecname,
-                                             zonename);
+                datasource->findPreviousName(task->qname, nsecname, zonename);
             }
 
             if (q.wantDnssec()) {
@@ -707,7 +706,7 @@ DataSrc::doQuery(Query& q)
 }
 
 DataSrc::Result
-DataSrc::findAddrs(const Query& q, const Name& qname, const RRClass& qclass,
+DataSrc::findAddrs(const Name& qname, const RRClass& qclass,
                    RRsetList& target, uint32_t& flags,
                    const Name* zonename) const
 {
@@ -715,13 +714,13 @@ DataSrc::findAddrs(const Query& q, const Name& qname, const RRClass& qclass,
     bool a = false, aaaa = false;
 
     flags = 0;
-    r = findExactRRset(q, qname, qclass, RRType::A(), target, flags, zonename);
+    r = findExactRRset(qname, qclass, RRType::A(), target, flags, zonename);
     if (r == SUCCESS && flags == 0) {
         a = true;
     }
 
     flags = 0;
-    r = findExactRRset(q, qname, qclass, RRType::AAAA(), target, flags,
+    r = findExactRRset(qname, qclass, RRType::AAAA(), target, flags,
                        zonename);
     if (r == SUCCESS && flags == 0) {
         aaaa = true;
@@ -737,7 +736,7 @@ DataSrc::findAddrs(const Query& q, const Name& qname, const RRClass& qclass,
 }
 
 DataSrc::Result
-DataSrc::findReferral(const Query& q, const Name& qname, const RRClass& qclass,
+DataSrc::findReferral(const Name& qname, const RRClass& qclass,
                       RRsetList& target, uint32_t& flags,
                       const Name* zonename) const
 {
@@ -745,7 +744,7 @@ DataSrc::findReferral(const Query& q, const Name& qname, const RRClass& qclass,
     bool ns = false, ds = false, dname = false;
 
     flags = 0;
-    r = findExactRRset(q, qname, qclass, RRType::NS(), target, flags, zonename);
+    r = findExactRRset(qname, qclass, RRType::NS(), target, flags, zonename);
     if (r == SUCCESS && flags == 0) {
         ns = true;
     } else if ((flags & (NO_SUCH_ZONE|NAME_NOT_FOUND))) {
@@ -753,7 +752,7 @@ DataSrc::findReferral(const Query& q, const Name& qname, const RRClass& qclass,
     }
 
     flags = 0;
-    r = findExactRRset(q, qname, qclass, RRType::DS(), target, flags, zonename);
+    r = findExactRRset(qname, qclass, RRType::DS(), target, flags, zonename);
     if (r == SUCCESS && flags == 0) {
         ds = true;
     } else if ((flags & (NO_SUCH_ZONE|NAME_NOT_FOUND))) {
@@ -761,7 +760,7 @@ DataSrc::findReferral(const Query& q, const Name& qname, const RRClass& qclass,
     }
 
     flags = 0;
-    r = findExactRRset(q, qname, qclass, RRType::DNAME(), target, flags,
+    r = findExactRRset(qname, qclass, RRType::DNAME(), target, flags,
                        zonename);
     if (r == SUCCESS && flags == 0) {
         dname = true;

src/lib/auth/data_source.h

@@ -110,16 +110,14 @@ public:
 
     // Mandatory 'low-level' methods: These will NOT be implemented by
     // the general DataSrc class; subclasses MUST implement them.
-    virtual Result findRRset(const Query& q,
-                             const isc::dns::Name& qname,
+    virtual Result findRRset(const isc::dns::Name& qname,
                              const isc::dns::RRClass& qclass,
                              const isc::dns::RRType& qtype,
                              isc::dns::RRsetList& target,
                              uint32_t& flags,
                              const isc::dns::Name* zonename) const = 0;
 
-    virtual Result findExactRRset(const Query& q,
-                                  const isc::dns::Name& qname,
+    virtual Result findExactRRset(const isc::dns::Name& qname,
                                   const isc::dns::RRClass& qclass,
                                   const isc::dns::RRType& qtype,
                                   isc::dns::RRsetList& target,
@@ -128,15 +126,13 @@ public:
 
     // These will have dumb implementations in the general DataSrc
     // class, and SHOULD be overwritten by subclasses.
-    virtual Result findAddrs(const Query& q,
-                             const isc::dns::Name& qname,
+    virtual Result findAddrs(const isc::dns::Name& qname,
                              const isc::dns::RRClass& qclass,
                              isc::dns::RRsetList& target,
                              uint32_t& flags,
                              const isc::dns::Name* zonename) const = 0;
 
-     virtual Result findReferral(const Query& q,
-                                 const isc::dns::Name& qname,
+     virtual Result findReferral(const isc::dns::Name& qname,
                                  const isc::dns::RRClass& qclass,
                                  isc::dns::RRsetList& target,
                                  uint32_t& flags,
@@ -144,15 +140,13 @@ public:
 
     // This MUST be implemented by concrete data sources which support
     // DNSSEC, but is optional for others (e.g., the static data source).
-    virtual Result findPreviousName(const Query& q,
-                                    const isc::dns::Name& qname,
+    virtual Result findPreviousName(const isc::dns::Name& qname,
                                     isc::dns::Name& target,
                                     const isc::dns::Name* zonename) const = 0;
 
    // This MUST be implemented by concrete data sources which support
    // NSEC3, but is optional for others
-   virtual Result findCoveringNSEC3(const Query& q,
-                                    const isc::dns::Name& zonename,
+   virtual Result findCoveringNSEC3(const isc::dns::Name& zonename,
                                     std::string& hash,
                                     isc::dns::RRsetList& target) const = 0;
 };
@@ -189,43 +183,37 @@ public:
     { return NOT_IMPLEMENTED; }
     Result close() { return NOT_IMPLEMENTED; }
 
-    virtual Result findRRset(const Query& q,
-                             const isc::dns::Name& qname,
+    virtual Result findRRset(const isc::dns::Name& qname,
                              const isc::dns::RRClass& qclass,
                              const isc::dns::RRType& qtype,
                              isc::dns::RRsetList& target,
                              uint32_t& flags,
                              const isc::dns::Name* zonename) const = 0;
 
-    virtual Result findExactRRset(const Query& q,
-                                  const isc::dns::Name& qname,
+    virtual Result findExactRRset(const isc::dns::Name& qname,
                                   const isc::dns::RRClass& qclass,
                                   const isc::dns::RRType& qtype,
                                   isc::dns::RRsetList& target,
                                   uint32_t& flags,
                                   const isc::dns::Name* zonename) const = 0;
 
-    virtual Result findAddrs(const Query& q,
-                             const isc::dns::Name& qname,
+    virtual Result findAddrs(const isc::dns::Name& qname,
                              const isc::dns::RRClass& qclass,
                              isc::dns::RRsetList& target,
                              uint32_t& flags,
                              const isc::dns::Name* zonename) const;
 
-    virtual Result findReferral(const Query& q,
-                                const isc::dns::Name& qname,
+    virtual Result findReferral(const isc::dns::Name& qname,
                                 const isc::dns::RRClass& qclass,
                                 isc::dns::RRsetList& target,
                                 uint32_t& flags,
                                 const isc::dns::Name* zonename) const;
 
-    virtual Result findPreviousName(const Query& q,
-                                    const isc::dns::Name& qname,
+    virtual Result findPreviousName(const isc::dns::Name& qname,
                                     isc::dns::Name& target,
                                     const isc::dns::Name* zonename) const = 0;
 
-   virtual Result findCoveringNSEC3(const Query& q,
-                                    const isc::dns::Name& zonename,
+   virtual Result findCoveringNSEC3(const isc::dns::Name& zonename,
                                     std::string& hash,
                                     isc::dns::RRsetList& target) const = 0;
 
@@ -264,8 +252,7 @@ public:
     // to get a pointer to the best concrete data source for the specified
     // zone, then send all queries directly to that data source.
 
-    Result findRRset(const Query& q UNUSED_PARAM,
-                     const isc::dns::Name& qname UNUSED_PARAM,
+    Result findRRset(const isc::dns::Name& qname UNUSED_PARAM,
                      const isc::dns::RRClass& qclass UNUSED_PARAM,
                      const isc::dns::RRType& qtype UNUSED_PARAM,
                      isc::dns::RRsetList& target UNUSED_PARAM,
@@ -275,8 +262,7 @@ public:
         return (NOT_IMPLEMENTED);
     }
 
-    Result findExactRRset(const Query& q UNUSED_PARAM,
-                          const isc::dns::Name& qname UNUSED_PARAM,
+    Result findExactRRset(const isc::dns::Name& qname UNUSED_PARAM,
                           const isc::dns::RRClass& qclass UNUSED_PARAM,
                           const isc::dns::RRType& qtype UNUSED_PARAM,
                           isc::dns::RRsetList& target UNUSED_PARAM,
@@ -286,8 +272,7 @@ public:
         return (NOT_IMPLEMENTED);
     }
 
-    Result findAddrs(const Query& q UNUSED_PARAM,
-                     const isc::dns::Name& qname UNUSED_PARAM,
+    Result findAddrs(const isc::dns::Name& qname UNUSED_PARAM,
                      const isc::dns::RRClass& qclass UNUSED_PARAM,
                      isc::dns::RRsetList& target UNUSED_PARAM,
                      uint32_t& flags UNUSED_PARAM,
@@ -296,8 +281,7 @@ public:
         return (NOT_IMPLEMENTED);
     }
 
-    Result findReferral(const Query& q UNUSED_PARAM,
-                        const isc::dns::Name& qname UNUSED_PARAM,
+    Result findReferral(const isc::dns::Name& qname UNUSED_PARAM,
                         const isc::dns::RRClass& qclass UNUSED_PARAM,
                         isc::dns::RRsetList& target UNUSED_PARAM,
                         uint32_t& flags UNUSED_PARAM,
@@ -307,7 +291,6 @@ public:
     }
 
     virtual Result findPreviousName(
-        const Query& q UNUSED_PARAM,
         const isc::dns::Name& qname UNUSED_PARAM,
         isc::dns::Name& target UNUSED_PARAM,
         const isc::dns::Name* zonename UNUSED_PARAM) const
@@ -316,7 +299,6 @@ public:
     }
 
    virtual Result findCoveringNSEC3(
-       const Query& q UNUSED_PARAM,
        const isc::dns::Name& zonename UNUSED_PARAM,
        std::string& hash UNUSED_PARAM,
        isc::dns::RRsetList& target UNUSED_PARAM) const

src/lib/auth/sqlite3_datasrc.cc

@@ -505,8 +505,7 @@ Sqlite3DataSrc::findClosestEnclosure(NameMatch& match,
 }
 
 DataSrc::Result
-Sqlite3DataSrc::findPreviousName(const Query& q,
-                                 const Name& qname,
+Sqlite3DataSrc::findPreviousName(const Name& qname,
                                  Name& target,
                                  const Name* zonename) const
 {
@@ -544,8 +543,7 @@ Sqlite3DataSrc::findPreviousName(const Query& q,
 }
 
 DataSrc::Result
-Sqlite3DataSrc::findCoveringNSEC3(const Query& q,
-                                  const Name& zonename,
+Sqlite3DataSrc::findCoveringNSEC3(const Name& zonename,
                                   string& hashstr,
                                   RRsetList& target) const
 {
@@ -616,8 +614,7 @@ Sqlite3DataSrc::findCoveringNSEC3(const Query& q,
 }
 
 DataSrc::Result
-Sqlite3DataSrc::findRRset(const Query& q,
-                          const Name& qname,
+Sqlite3DataSrc::findRRset(const Name& qname,
                           const RRClass& qclass,
                           const RRType& qtype,
                           RRsetList& target,
@@ -629,8 +626,7 @@ Sqlite3DataSrc::findRRset(const Query& q,
 }
 
 DataSrc::Result
-Sqlite3DataSrc::findExactRRset(const Query& q,
-                               const Name& qname,
+Sqlite3DataSrc::findExactRRset(const Name& qname,
                                const RRClass& qclass,
                                const RRType& qtype,
                                RRsetList& target,
@@ -652,8 +648,7 @@ Sqlite3DataSrc::findExactRRset(const Query& q,
 }
 
 DataSrc::Result
-Sqlite3DataSrc::findAddrs(const Query& q,
-                          const Name& qname,
+Sqlite3DataSrc::findAddrs(const Name& qname,
                           const RRClass& qclass,
                           RRsetList& target,
                           uint32_t& flags,
@@ -664,8 +659,7 @@ Sqlite3DataSrc::findAddrs(const Query& q,
 }
 
 DataSrc::Result
-Sqlite3DataSrc::findReferral(const Query& q,
-                             const Name& qname,
+Sqlite3DataSrc::findReferral(const Name& qname,
                              const RRClass& qclass,
                              RRsetList& target,
                              uint32_t& flags,

src/lib/auth/sqlite3_datasrc.h

@@ -62,43 +62,37 @@ public:
     void findClosestEnclosure(NameMatch& match,
                               const isc::dns::RRClass& qclass) const;
 
-    Result findRRset(const Query& q,
-                     const isc::dns::Name& qname,
+    Result findRRset(const isc::dns::Name& qname,
                      const isc::dns::RRClass& qclass,
                      const isc::dns::RRType& qtype,
                      isc::dns::RRsetList& target,
                      uint32_t& flags,
                      const isc::dns::Name* zonename) const;
 
-    Result findExactRRset(const Query& q,
-                          const isc::dns::Name& qname,
+    Result findExactRRset(const isc::dns::Name& qname,
                           const isc::dns::RRClass& qclass,
                           const isc::dns::RRType& qtype,
                           isc::dns::RRsetList& target,
                           uint32_t& flags,
                           const isc::dns::Name* zonename) const;
 
-    Result findAddrs(const Query& q,
-                       const isc::dns::Name& qname,
-                       const isc::dns::RRClass& qclass,
-                       isc::dns::RRsetList& target,
-                       uint32_t& flags,
-                       const isc::dns::Name* zonename) const;
+    Result findAddrs(const isc::dns::Name& qname,
+                     const isc::dns::RRClass& qclass,
+                     isc::dns::RRsetList& target,
+                     uint32_t& flags,
+                     const isc::dns::Name* zonename) const;
 
-    Result findReferral(const Query& q,
-                        const isc::dns::Name& qname,
+    Result findReferral(const isc::dns::Name& qname,
                         const isc::dns::RRClass& qclass,
                         isc::dns::RRsetList& target,
                         uint32_t& flags,
                         const isc::dns::Name* zonename) const;
 
-    DataSrc::Result findPreviousName(const Query& q,
-                                     const isc::dns::Name& qname,
+    DataSrc::Result findPreviousName(const isc::dns::Name& qname,
                                      isc::dns::Name& target,
                                      const isc::dns::Name* zonename) const;
 
-    Result findCoveringNSEC3(const Query& q,
-                             const isc::dns::Name& zonename,
+    Result findCoveringNSEC3(const isc::dns::Name& zonename,
                              std::string& hash,
                              isc::dns::RRsetList& target) const;
 

src/lib/auth/static_datasrc.cc

@@ -14,6 +14,8 @@
 
 // $Id$
 
+#include "config.h"
+
 #include <dns/name.h>
 #include <dns/rdataclass.h>
 #include <dns/rrclass.h>
@@ -126,7 +128,7 @@ StaticDataSrc::findClosestEnclosure(NameMatch& match,
 }
 
 DataSrc::Result
-StaticDataSrc::findRRset(const Query& q, const Name& qname,
+StaticDataSrc::findRRset(const Name& qname,
                          const RRClass& qclass, const RRType& qtype,
                          RRsetList& target, uint32_t& flags,
                          const Name* zonename) const
@@ -164,24 +166,26 @@ StaticDataSrc::findRRset(const Query& q, const Name& qname,
 }
 
 DataSrc::Result
-StaticDataSrc::findExactRRset(const Query& q, const Name& qname,
+StaticDataSrc::findExactRRset(const Name& qname,
                               const RRClass& qclass, const RRType& qtype,
                               RRsetList& target, uint32_t& flags,
                               const Name* zonename) const
 {
-    return (findRRset(q, qname, qclass, qtype, target, flags, zonename));
+    return (findRRset(qname, qclass, qtype, target, flags, zonename));
 }
 
 DataSrc::Result
-StaticDataSrc::findPreviousName(const Query& q, const Name& qname,
-                                Name& target, const Name* zonename) const
+StaticDataSrc::findPreviousName(const Name& qname UNUSED_PARAM,
+                                Name& target UNUSED_PARAM,
+                                const Name* zonename UNUSED_PARAM) const
 {
     return (NOT_IMPLEMENTED);
 }
 
 DataSrc::Result
-StaticDataSrc::findCoveringNSEC3(const Query& q, const Name& zonename,
-                                 string& hash, RRsetList& target) const
+StaticDataSrc::findCoveringNSEC3(const Name& zonename UNUSED_PARAM,
+                                 string& hash UNUSED_PARAM,
+                                 RRsetList& target UNUSED_PARAM) const
 {
    return (NOT_IMPLEMENTED);
 }

src/lib/auth/static_datasrc.h

@@ -61,29 +61,25 @@ public:
     void findClosestEnclosure(NameMatch& match,
                               const isc::dns::RRClass& qclass) const;
 
-    Result findRRset(const Query& q,
-                     const isc::dns::Name& qname,
+    Result findRRset(const isc::dns::Name& qname,
                      const isc::dns::RRClass& qclass,
                      const isc::dns::RRType& qtype,
                      isc::dns::RRsetList& target,
                      uint32_t& flags,
                      const isc::dns::Name* zonename) const;
 
-    Result findExactRRset(const Query& q,
-                          const isc::dns::Name& qname,
+    Result findExactRRset(const isc::dns::Name& qname,
                           const isc::dns::RRClass& qclass,
                           const isc::dns::RRType& qtype,
                           isc::dns::RRsetList& target,
                           uint32_t& flags,
                           const isc::dns::Name* zonename) const;
 
-    Result findPreviousName(const Query& q,
-                            const isc::dns::Name& qname,
+    Result findPreviousName(const isc::dns::Name& qname,
                             isc::dns::Name& target,
                             const isc::dns::Name* zonename) const;
 
-   Result findCoveringNSEC3(const Query& q,
-                            const isc::dns::Name& zonename,
+   Result findCoveringNSEC3(const isc::dns::Name& zonename,
                             std::string& hash,
                             isc::dns::RRsetList& target) const;
 

src/lib/auth/tests/sqlite3_unittest.cc

@@ -88,19 +88,12 @@ typedef enum {
 
 class Sqlite3DataSourceTest : public ::testing::Test {
 protected:
-    Sqlite3DataSourceTest() : message(Message::PARSE),
-                              query(NULL), rrclass(RRClass::IN()),
+    Sqlite3DataSourceTest() : rrclass(RRClass::IN()),
                               rrtype(RRType::A()), rrttl(RRTTL(3600)),
                               find_flags(0), rrset_matched(0), rrset_count(0)
     {
         data_source.init(SQLITE_DBFILE_EXAMPLE);
 
-        // the data source will ignore the message, and the encapsulating
-        // query object so the content doesn't matter.
-        // (it's a bad practice, but is a different issue)
-        message.addQuestion(Question(Name("example.org"), rrclass, rrtype));
-        query = new Query(message, true);
-
         common_a_data.push_back("192.0.2.1");
         common_sig_data.push_back("A 5 3 3600" + sigdata_common);
         common_aaaa_data.push_back("2001:db8::1234");
@@ -161,10 +154,7 @@ protected:
                                  "20100306201820 33495 sql2.example.com. "
                                  "FAKEFAKEFAKEFAKE");
     }
-    ~Sqlite3DataSourceTest() { delete query; }
     Sqlite3DataSrc data_source;
-    Message message;
-    Query* query;
     // we allow these to be modified in the test
     RRClass rrclass;
     RRType rrtype;
@@ -267,7 +257,7 @@ checkRRset(RRsetPtr rrset, const Name& expected_name,
 }
 
 void
-checkFind(FindMode mode, const Sqlite3DataSrc& data_source, const Query& query,
+checkFind(FindMode mode, const Sqlite3DataSrc& data_source,
           const Name& expected_name, const Name* zone_name,
           const RRClass& expected_class, const RRType& expected_type,
           const vector<RRTTL>& expected_ttls, const uint32_t expected_flags,
@@ -283,25 +273,25 @@ checkFind(FindMode mode, const Sqlite3DataSrc& data_source, const Query& query,
     switch (mode) {
     case NORMAL:
         EXPECT_EQ(DataSrc::SUCCESS,
-                  data_source.findRRset(query, expected_name, expected_class,
+                  data_source.findRRset(expected_name, expected_class,
                                         expected_type, result_sets, find_flags,
                                         zone_name));
         break;
     case EXACT:
         EXPECT_EQ(DataSrc::SUCCESS,
-                  data_source.findExactRRset(query, expected_name,
+                  data_source.findExactRRset(expected_name,
                                              expected_class, expected_type,
                                              result_sets, find_flags,
                                              zone_name));
         break;
     case ADDRESS:
         EXPECT_EQ(DataSrc::SUCCESS,
-                  data_source.findAddrs(query, expected_name, expected_class,
+                  data_source.findAddrs(expected_name, expected_class,
                                         result_sets, find_flags, zone_name));
         break;
     case REFERRAL:
         EXPECT_EQ(DataSrc::SUCCESS,
-                  data_source.findReferral(query, expected_name, expected_class,
+                  data_source.findReferral(expected_name, expected_class,
                                            result_sets, find_flags, zone_name));
         break;
     }
@@ -327,7 +317,7 @@ checkFind(FindMode mode, const Sqlite3DataSrc& data_source, const Query& query,
 }
 
 void
-checkFind(FindMode mode, const Sqlite3DataSrc& data_source, const Query& query,
+checkFind(FindMode mode, const Sqlite3DataSrc& data_source,
           const Name& expected_name, const Name* zone_name,
           const RRClass& expected_class, const RRType& expected_type,
           const RRTTL& expected_rrttl, const uint32_t expected_flags,
@@ -344,7 +334,7 @@ checkFind(FindMode mode, const Sqlite3DataSrc& data_source, const Query& query,
     answers.push_back(&expected_data);
     signatures.push_back(expected_sig_data);
 
-    checkFind(mode, data_source, query, expected_name, zone_name,
+    checkFind(mode, data_source, expected_name, zone_name,
               expected_class, expected_type, ttls, expected_flags, types,
               answers, signatures);
 }
@@ -405,15 +395,15 @@ TEST_F(Sqlite3DataSourceTest, findClosestEnclosureNoMatch) {
 
 TEST_F(Sqlite3DataSourceTest, findRRsetNormal) {
     // Without specifying the zone name, and then with the zone name
-    checkFind(NORMAL, data_source, *query, www_name, NULL, rrclass, rrtype,
+    checkFind(NORMAL, data_source, www_name, NULL, rrclass, rrtype,
               rrttl, 0, common_a_data, &common_sig_data);
 
-    checkFind(NORMAL, data_source, *query, www_name, &zone_name, rrclass,
+    checkFind(NORMAL, data_source, www_name, &zone_name, rrclass,
               rrtype, rrttl, 0, common_a_data, &common_sig_data);
 
     // With a zone name that doesn't match
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, www_name, rrclass, rrtype,
+              data_source.findRRset(www_name, rrclass, rrtype,
                                     result_sets, find_flags, &nomatch_name));
     EXPECT_EQ(DataSrc::NO_SUCH_ZONE, find_flags);
     EXPECT_TRUE(result_sets.begin() == result_sets.end()); // should be empty
@@ -430,23 +420,23 @@ TEST_F(Sqlite3DataSourceTest, findRRsetNormalANY) {
     signatures.push_back(&www_nsec_sig_data);
 
     rrtype = RRType::ANY();
-    checkFind(NORMAL, data_source, *query, www_name, NULL, rrclass, rrtype,
+    checkFind(NORMAL, data_source, www_name, NULL, rrclass, rrtype,
               ttls, 0, types, answers, signatures);
 
-    checkFind(NORMAL, data_source, *query, www_name, &zone_name, rrclass,
+    checkFind(NORMAL, data_source, www_name, &zone_name, rrclass,
               rrtype, ttls, 0, types, answers, signatures);
 }
 
 // Case insensitive lookup
 TEST_F(Sqlite3DataSourceTest, findRRsetNormalCase) {
-    checkFind(NORMAL, data_source, *query, www_upper_name, NULL, rrclass,
+    checkFind(NORMAL, data_source, www_upper_name, NULL, rrclass,
               rrtype, rrttl, 0, common_a_data, &common_sig_data);
 
-    checkFind(NORMAL, data_source, *query, www_upper_name, &zone_name, rrclass,
+    checkFind(NORMAL, data_source, www_upper_name, &zone_name, rrclass,
               rrtype, rrttl, 0, common_a_data, &common_sig_data);
 
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, www_upper_name, rrclass, rrtype,
+              data_source.findRRset(www_upper_name, rrclass, rrtype,
                                     result_sets, find_flags, &nomatch_name));
     EXPECT_EQ(DataSrc::NO_SUCH_ZONE, find_flags);
     EXPECT_TRUE(result_sets.begin() == result_sets.end()); // should be empty
@@ -454,15 +444,15 @@ TEST_F(Sqlite3DataSourceTest, findRRsetNormalCase) {
 
 TEST_F(Sqlite3DataSourceTest, findRRsetApexNS) {
     rrtype = RRType::NS();
-    checkFind(NORMAL, data_source, *query, zone_name, NULL, rrclass, rrtype,
+    checkFind(NORMAL, data_source, zone_name, NULL, rrclass, rrtype,
               rrttl, DataSrc::REFERRAL, apex_ns_data, &apex_ns_sig_data);
 
-    checkFind(NORMAL, data_source, *query, zone_name, &zone_name, rrclass,
+    checkFind(NORMAL, data_source, zone_name, &zone_name, rrclass,
               rrtype, rrttl, DataSrc::REFERRAL, apex_ns_data,
               &apex_ns_sig_data);
 
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, zone_name, rrclass, rrtype,
+              data_source.findRRset(zone_name, rrclass, rrtype,
                                     result_sets, find_flags, &nomatch_name));
     EXPECT_EQ(DataSrc::NO_SUCH_ZONE, find_flags);
     EXPECT_TRUE(result_sets.begin() == result_sets.end()); // should be empty
@@ -491,10 +481,10 @@ TEST_F(Sqlite3DataSourceTest, findRRsetApexANY) {
     signatures.push_back(&apex_dnskey_sig_data);
 
     rrtype = RRType::ANY();
-    checkFind(NORMAL, data_source, *query, zone_name, NULL, rrclass, rrtype,
+    checkFind(NORMAL, data_source, zone_name, NULL, rrclass, rrtype,
               ttls, 0, types, answers, signatures);
 
-    checkFind(NORMAL, data_source, *query, zone_name, &zone_name, rrclass,
+    checkFind(NORMAL, data_source, zone_name, &zone_name, rrclass,
               rrtype, ttls, 0, types, answers, signatures);
 }
 
@@ -512,14 +502,14 @@ TEST_F(Sqlite3DataSourceTest, findRRsetMixedANY) {
     signatures.push_back(NULL);
 
     rrtype = RRType::ANY();
-    checkFind(NORMAL, data_source, *query, qname, &zone_name, rrclass,
+    checkFind(NORMAL, data_source, qname, &zone_name, rrclass,
               rrtype, ttls, 0, types, answers, signatures);
 }
 
 TEST_F(Sqlite3DataSourceTest, findRRsetApexNXRRSET) {
     rrtype = RRType::AAAA();
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, zone_name, rrclass, rrtype,
+              data_source.findRRset(zone_name, rrclass, rrtype,
                                     result_sets, find_flags, &zone_name));
     // there's an NS RRset at the apex name, so the REFERRAL flag should be
     // set, too.
@@ -528,7 +518,7 @@ TEST_F(Sqlite3DataSourceTest, findRRsetApexNXRRSET) {
 
     // Same test, without specifying the zone name
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, zone_name, rrclass, rrtype,
+              data_source.findRRset(zone_name, rrclass, rrtype,
                                     result_sets, find_flags, NULL));
     // there's an NS RRset at the apex name, so the REFERRAL flag should be
     // set, too.
@@ -540,9 +530,9 @@ TEST_F(Sqlite3DataSourceTest, findRRsetApexNXRRSET) {
 // point of view, but perform minimal tests anyway.
 TEST_F(Sqlite3DataSourceTest, findRRsetWildcard) {
     const Name qname("*.wild.example.com");
-    checkFind(NORMAL, data_source, *query, qname, NULL, rrclass,
+    checkFind(NORMAL, data_source, qname, NULL, rrclass,
               rrtype, rrttl, 0, wild_a_data, &common_sig_data);
-    checkFind(NORMAL, data_source, *query, qname, &zone_name, rrclass,
+    checkFind(NORMAL, data_source, qname, &zone_name, rrclass,
               rrtype, rrttl, 0, wild_a_data, &common_sig_data);
 }
 
@@ -551,13 +541,13 @@ TEST_F(Sqlite3DataSourceTest, findRRsetEmptyNode) {
     const Name qname("bar.example.com");
 
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, qname, rrclass, rrtype,
+              data_source.findRRset(qname, rrclass, rrtype,
                                     result_sets, find_flags, NULL));
     EXPECT_EQ(DataSrc::TYPE_NOT_FOUND, find_flags);
     EXPECT_TRUE(result_sets.begin() == result_sets.end());
 
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, qname, rrclass, rrtype,
+              data_source.findRRset(qname, rrclass, rrtype,
                                     result_sets, find_flags, &zone_name));
     EXPECT_EQ(DataSrc::TYPE_NOT_FOUND, find_flags);
     EXPECT_TRUE(result_sets.begin() == result_sets.end());
@@ -569,9 +559,9 @@ TEST_F(Sqlite3DataSourceTest, findRRsetDNAME) {
     const Name qname("dname.example.com");
 
     rrtype = RRType::DNAME();
-    checkFind(NORMAL, data_source, *query, qname, NULL, rrclass,
+    checkFind(NORMAL, data_source, qname, NULL, rrclass,
               rrtype, rrttl, 0, dname_data, &dname_sig_data);
-    checkFind(NORMAL, data_source, *query, qname, &zone_name, rrclass,
+    checkFind(NORMAL, data_source, qname, &zone_name, rrclass,
               rrtype, rrttl, 0, dname_data, &dname_sig_data);
 }
 
@@ -581,9 +571,9 @@ TEST_F(Sqlite3DataSourceTest, findRRsetCNAME) {
     // This qname only has the CNAME (+ sigs).  CNAME query is not different
     // from ordinary queries.
     rrtype = RRType::CNAME();
-    checkFind(NORMAL, data_source, *query, qname, NULL, rrclass,
+    checkFind(NORMAL, data_source, qname, NULL, rrclass,
               rrtype, rrttl, 0, cname_data, &cname_sig_data);
-    checkFind(NORMAL, data_source, *query, qname, &zone_name, rrclass,
+    checkFind(NORMAL, data_source, qname, &zone_name, rrclass,
               rrtype, rrttl, 0, cname_data, &cname_sig_data);
 
     // queries for (ordinary) different RR types that match the CNAME.
@@ -593,18 +583,18 @@ TEST_F(Sqlite3DataSourceTest, findRRsetCNAME) {
     ttls.push_back(rrttl);
     answers.push_back(&cname_data);
     signatures.push_back(&cname_sig_data);
-    checkFind(NORMAL, data_source, *query, qname, NULL, rrclass,
+    checkFind(NORMAL, data_source, qname, NULL, rrclass,
               rrtype, ttls, DataSrc::CNAME_FOUND, types, answers, signatures);
-    checkFind(NORMAL, data_source, *query, qname, &zone_name, rrclass,
+    checkFind(NORMAL, data_source, qname, &zone_name, rrclass,
               rrtype, ttls, DataSrc::CNAME_FOUND, types, answers, signatures);
 
     // NSEC query that match the CNAME.
     // CNAME_FOUND flag is NOT set, and the NSEC RR is returned instead of
     // CNAME.
     rrtype = RRType::NSEC();
-    checkFind(NORMAL, data_source, *query, qname, NULL, rrclass,
+    checkFind(NORMAL, data_source, qname, NULL, rrclass,
               rrtype, RRTTL(7200), 0, cname_nsec_data, &cname_nsec_sig_data);
-    checkFind(NORMAL, data_source, *query, qname, &zone_name, rrclass,
+    checkFind(NORMAL, data_source, qname, &zone_name, rrclass,
               rrtype, RRTTL(7200), 0, cname_nsec_data, &cname_nsec_sig_data);
 }
 
@@ -614,7 +604,7 @@ TEST_F(Sqlite3DataSourceTest, findRRsetDelegation) {
     // query for a name under a zone cut.  From the data source API point
     // of view this is no different than "NXDOMAIN".
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, qname, rrclass, rrtype,
+              data_source.findRRset(qname, rrclass, rrtype,
                                     result_sets, find_flags, NULL));
     EXPECT_EQ(DataSrc::NAME_NOT_FOUND, find_flags);
     EXPECT_TRUE(result_sets.begin() == result_sets.end());
@@ -629,13 +619,13 @@ TEST_F(Sqlite3DataSourceTest, findRRsetDelegationAtZoneCut) {
     // For non-NS ordinary queries, "no type" should be set too, and no RRset is
     // returned.
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, qname, rrclass, rrtype,
+              data_source.findRRset(qname, rrclass, rrtype,
                                     result_sets, find_flags, NULL));
     EXPECT_EQ(DataSrc::TYPE_NOT_FOUND | DataSrc::REFERRAL, find_flags);
     EXPECT_TRUE(result_sets.begin() == result_sets.end());
 
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, qname, rrclass, rrtype,
+              data_source.findRRset(qname, rrclass, rrtype,
                                     result_sets, find_flags, &zone_name));
     EXPECT_EQ(DataSrc::TYPE_NOT_FOUND | DataSrc::REFERRAL, find_flags);
     EXPECT_TRUE(result_sets.begin() == result_sets.end());
@@ -643,16 +633,16 @@ TEST_F(Sqlite3DataSourceTest, findRRsetDelegationAtZoneCut) {
     // For NS query, RRset is returned with the REFERRAL flag.  No RRSIG should
     // be provided.
     rrtype = RRType::NS();
-    checkFind(NORMAL, data_source, *query, qname, NULL, rrclass,
+    checkFind(NORMAL, data_source, qname, NULL, rrclass,
               rrtype, rrttl, DataSrc::REFERRAL, delegation_ns_data, NULL);
-    checkFind(NORMAL, data_source, *query, qname, &zone_name, rrclass,
+    checkFind(NORMAL, data_source, qname, &zone_name, rrclass,
               rrtype, rrttl, DataSrc::REFERRAL, delegation_ns_data, NULL);
 
     // For ANY query.  What should we do?
 #if 0
     rrtype = RRType::ANY();
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, qname, rrclass, rrtype,
+              data_source.findRRset(qname, rrclass, rrtype,
                                     result_sets, find_flags, NULL));
     EXPECT_EQ(DataSrc::REFERRAL, find_flags);
 #endif
@@ -661,10 +651,10 @@ TEST_F(Sqlite3DataSourceTest, findRRsetDelegationAtZoneCut) {
     // without REFERRAL.  But it currently doesn't act like so.
 #if 0
     rrtype = RRType::NSEC();
-    checkFind(NORMAL, data_source, *query, qname, NULL, rrclass,
+    checkFind(NORMAL, data_source, qname, NULL, rrclass,
               rrtype, RRTTL(7200), 0, delegation_nsec_data,
               &delegation_nsec_sig_data);
-    checkFind(NORMAL, data_source, *query, qname, &zone_name, rrclass,
+    checkFind(NORMAL, data_source, qname, &zone_name, rrclass,
               rrtype, RRTTL(7200), 0, delegation_nsec_data,
               &delegation_nsec_sig_data);
 #endif    
@@ -676,25 +666,25 @@ TEST_F(Sqlite3DataSourceTest, findRRsetInChildZone) {
 
     // If we don't specify the zone, the data source should identify the
     // best matching zone.
-    checkFind(NORMAL, data_source, *query, qname, NULL, rrclass,
+    checkFind(NORMAL, data_source, qname, NULL, rrclass,
               rrtype, rrttl, 0, child_a_data, &child_sig_data);
 
     // If we specify the parent zone, it's treated as NXDOMAIN because it's
     // under a zone cut.
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, qname, rrclass, rrtype,
+              data_source.findRRset(qname, rrclass, rrtype,
                                     result_sets, find_flags, &zone_name));
     EXPECT_EQ(DataSrc::NAME_NOT_FOUND, find_flags);
     EXPECT_TRUE(result_sets.begin() == result_sets.end());
 
     // If we specify the child zone, it should be the same as the first case.
-    checkFind(NORMAL, data_source, *query, qname, &child_zone_name, rrclass,
+    checkFind(NORMAL, data_source, qname, &child_zone_name, rrclass,
               rrtype, rrttl, 0, child_a_data, &child_sig_data);
 }
 
 TEST_F(Sqlite3DataSourceTest, findExactRRset) {
     // Normal case.  No different than findRRset.
-    checkFind(EXACT, data_source, *query, www_name, &zone_name, rrclass, rrtype,
+    checkFind(EXACT, data_source, www_name, &zone_name, rrclass, rrtype,
               rrttl, 0, common_a_data, &common_sig_data);
 }
 
@@ -704,7 +694,7 @@ TEST_F(Sqlite3DataSourceTest, findRRsetNSEC3) {
 
     const Name nsec3_zonename("sql2.example.com");
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findCoveringNSEC3(*query, nsec3_zonename,
+              data_source.findCoveringNSEC3(nsec3_zonename,
                                             hashstr, result_sets));
     RRsetList::iterator it = result_sets.begin();
     checkRRset(*it, Name(hashstr).concatenate(nsec3_zonename), rrclass,
@@ -720,7 +710,7 @@ TEST_F(Sqlite3DataSourceTest, findExactRRsetCNAME) {
     // This qname only has the CNAME (+ sigs).  In this case it should be
     // no different than findRRset for CNAME query.
     rrtype = RRType::CNAME();
-    checkFind(NORMAL, data_source, *query, qname, &zone_name, rrclass,
+    checkFind(NORMAL, data_source, qname, &zone_name, rrclass,
               rrtype, rrttl, 0, cname_data, &cname_sig_data);
 
     // queries for (ordinary) different RR types that match the CNAME.
@@ -731,7 +721,7 @@ TEST_F(Sqlite3DataSourceTest, findExactRRsetCNAME) {
     ttls.push_back(rrttl);
     answers.push_back(&cname_data);
     signatures.push_back(&cname_sig_data);
-    checkFind(EXACT, data_source, *query, qname, &zone_name, rrclass,
+    checkFind(EXACT, data_source, qname, &zone_name, rrclass,
               rrtype, ttls, DataSrc::TYPE_NOT_FOUND, types, answers,
               signatures);
 }
@@ -751,7 +741,7 @@ TEST_F(Sqlite3DataSourceTest, findReferralRRset) {
     signatures.push_back(&delegation_ds_sig_data);
     // Note: zone_name matters here because we need to perform the search
     // in the parent zone.
-    checkFind(REFERRAL, data_source, *query, qname, &zone_name, rrclass,
+    checkFind(REFERRAL, data_source, qname, &zone_name, rrclass,
               rrtype, ttls, 0, types, answers, signatures);
 }
 #endif
@@ -759,14 +749,14 @@ TEST_F(Sqlite3DataSourceTest, findReferralRRset) {
 TEST_F(Sqlite3DataSourceTest, findReferralRRsetDNAME) {
     // same as above.  the DNAME case.
     const Name qname("dname.example.com");
-    checkFind(REFERRAL, data_source, *query, qname, &zone_name, rrclass,
+    checkFind(REFERRAL, data_source, qname, &zone_name, rrclass,
               RRType::DNAME(), rrttl, 0, dname_data, &dname_sig_data);
 }
 
 TEST_F(Sqlite3DataSourceTest, findReferralRRsetFail) {
     // qname has not "referral" records.  the result should be "empty".
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findReferral(*query, www_name, rrclass,
+              data_source.findReferral(www_name, rrclass,
                                        result_sets, find_flags, &zone_name));
     EXPECT_EQ(DataSrc::TYPE_NOT_FOUND, find_flags);
     EXPECT_TRUE(result_sets.begin() == result_sets.end());
@@ -776,11 +766,11 @@ TEST_F(Sqlite3DataSourceTest, findAddressRRset) {
     // A referral lookup searches for A or AAAA, or their sigs.
 
     // A-only case
-    checkFind(ADDRESS, data_source, *query, www_name, &zone_name, rrclass,
+    checkFind(ADDRESS, data_source, www_name, &zone_name, rrclass,
               rrtype, rrttl, 0, common_a_data, &common_sig_data);
 
     // AAAA-only case
-    checkFind(ADDRESS, data_source, *query, Name("ip6.example.com"), &zone_name,
+    checkFind(ADDRESS, data_source, Name("ip6.example.com"), &zone_name,
               rrclass, RRType::AAAA(), rrttl, 0, common_aaaa_data,
               &common_aaaa_sig_data);
 
@@ -793,12 +783,12 @@ TEST_F(Sqlite3DataSourceTest, findAddressRRset) {
     ttls.push_back(rrttl);
     answers.push_back(&common_aaaa_data);
     signatures.push_back(&common_aaaa_sig_data);
-    checkFind(ADDRESS, data_source, *query, Name("ip46.example.com"),
+    checkFind(ADDRESS, data_source, Name("ip46.example.com"),
               &zone_name, rrclass, rrtype, ttls, 0, types, answers, signatures);
 
     // The qname doesn't have no address records.
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findAddrs(*query, Name("text.example.com"), rrclass,
+              data_source.findAddrs(Name("text.example.com"), rrclass,
                                     result_sets, find_flags, &zone_name));
     EXPECT_EQ(DataSrc::TYPE_NOT_FOUND, find_flags);
     EXPECT_TRUE(result_sets.begin() == result_sets.end());

src/lib/auth/tests/static_unittest.cc

@@ -41,20 +41,12 @@ using namespace isc::auth;
 namespace {
 class StaticDataSourceTest : public ::testing::Test {
 protected:
-    StaticDataSourceTest() : message(Message::PARSE),
-                             query(NULL),
-                             version_name("version.bind"),
+    StaticDataSourceTest() : version_name("version.bind"),
                              authors_name("authors.bind"),
                              nomatch_name("example.com"),
                              rrclass(RRClass::CH()), rrtype(RRType::TXT()),
                              rrttl(RRTTL(0)), find_flags(0), matched_rdata(0)
     {
-        // static data source will ignore the message, and the encapsulating
-        // query object so the content doesn't matter.
-        // (it's a bad practice, but it's a different issue)
-        message.addQuestion(Question(Name(version_name), rrclass, rrtype));
-        query = new Query(message, true);
-
         // XXX: the following values can change as release/developers change,
         // in which case the test code must be updated accordingly.
         version_data.push_back("BIND10 0.0.0 (pre-alpha)");
@@ -75,10 +67,7 @@ protected:
         version_ns_data.push_back("version.bind.");
         authors_ns_data.push_back("authors.bind.");
     }
-    ~StaticDataSourceTest() { delete query; }
     StaticDataSrc data_source;
-    Message message;
-    Query* query;
     const Name version_name;
     const Name authors_name;
     const Name nomatch_name;
@@ -168,7 +157,7 @@ TEST_F(StaticDataSourceTest, findClosestEnclosureNoMatch) {
 
 TEST_F(StaticDataSourceTest, findRRsetVersionTXT) {
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, version_name, rrclass, rrtype,
+              data_source.findRRset(version_name, rrclass, rrtype,
                                     result_sets, find_flags, NULL));
     EXPECT_EQ(0, find_flags);
     // There should be only item in result_sets, which should be
@@ -186,7 +175,7 @@ TEST_F(StaticDataSourceTest, findRRsetVersionTXT) {
 TEST_F(StaticDataSourceTest, findRRsetVersionNS) {
     rrtype = RRType::NS();
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, version_name, rrclass, rrtype,
+              data_source.findRRset(version_name, rrclass, rrtype,
                                     result_sets, find_flags, NULL));
     EXPECT_EQ(0, find_flags);
     RRsetList::iterator it = result_sets.begin();
@@ -202,7 +191,7 @@ TEST_F(StaticDataSourceTest, findRRsetVersionNS) {
 
 TEST_F(StaticDataSourceTest, findRRsetAuthorsTXT) {
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, authors_name, rrclass, rrtype,
+              data_source.findRRset(authors_name, rrclass, rrtype,
                                     result_sets, find_flags, NULL));
     EXPECT_EQ(0, find_flags);
     RRsetList::iterator it = result_sets.begin();
@@ -218,7 +207,7 @@ TEST_F(StaticDataSourceTest, findRRsetAuthorsTXT) {
 TEST_F(StaticDataSourceTest, findRRsetAuthorsNS) {
     rrtype = RRType::NS();
     EXPECT_EQ(DataSrc::SUCCESS,
-              data_source.findRRset(*query, authors_name, rrclass, rrtype,
+              data_source.findRRset(authors_name, rrclass, rrtype,
                                     result_sets, find_flags, NULL));
     EXPECT_EQ(0, find_flags);
     RRsetList::iterator it = result_sets.begin();

src/lib/auth/tests/test_datasrc.cc

@@ -14,6 +14,8 @@
 
 // $Id$
 
+#include "config.h"
+
 #include <cassert>
 
 #include "unittest_util.h"
@@ -97,7 +99,7 @@ RRsetPtr loop2_cname;
 }
 
 DataSrc::Result
-TestDataSrc::init(const isc::data::ElementPtr config)
+TestDataSrc::init(const isc::data::ElementPtr config UNUSED_PARAM)
 {
     return init();
 }
@@ -683,9 +685,8 @@ TestDataSrc::findRecords(const Name& name, const RRType& rdtype,
 }
 
 DataSrc::Result
-TestDataSrc::findRRset(const Query& q,
-                       const Name& qname,
-                       const RRClass& qclass,
+TestDataSrc::findRRset(const Name& qname,
+                       const RRClass& qclass UNUSED_PARAM,
                        const RRType& qtype,
                        RRsetList& target,
                        uint32_t& flags,
@@ -696,9 +697,8 @@ TestDataSrc::findRRset(const Query& q,
 }
 
 DataSrc::Result
-TestDataSrc::findExactRRset(const Query& q,
-                            const Name& qname,
-                            const RRClass& qclass,
+TestDataSrc::findExactRRset(const Name& qname,
+                            const RRClass& qclass UNUSED_PARAM,
                             const RRType& qtype,
                             RRsetList& target,
                             uint32_t& flags,
@@ -718,21 +718,19 @@ TestDataSrc::findExactRRset(const Query& q,
 }
 
 DataSrc::Result
-TestDataSrc::findAddrs(const Query& q,
-                        const Name& qname,
-                        const RRClass& qclass,
-                        RRsetList& target,
-                        uint32_t& flags,
-                        const Name* zonename) const
+TestDataSrc::findAddrs(const Name& qname,
+                       const RRClass& qclass UNUSED_PARAM,
+                       RRsetList& target,
+                       uint32_t& flags,
+                       const Name* zonename) const
 {
     findRecords(qname, RRType::ANY(), target, zonename, ADDRESS, flags);
     return (SUCCESS);
 }
 
 DataSrc::Result
-TestDataSrc::findReferral(const Query& q,
-                          const Name& qname,
-                          const RRClass& qclass,
+TestDataSrc::findReferral(const Name& qname,
+                          const RRClass& qclass UNUSED_PARAM,
                           RRsetList& target,
                           uint32_t& flags,
                           const Name* zonename) const
@@ -742,8 +740,7 @@ TestDataSrc::findReferral(const Query& q,
 }
 
 DataSrc::Result
-TestDataSrc::findPreviousName(const Query& q,
-                              const Name& qname,
+TestDataSrc::findPreviousName(const Name& qname,
                               Name& target,
                               const Name* zonename) const
 {
@@ -786,10 +783,9 @@ TestDataSrc::findPreviousName(const Query& q,
 }
 
 DataSrc::Result
-TestDataSrc::findCoveringNSEC3(const Query& q,
-                               const Name& zonename,
-                               string& hash,
-                               RRsetList& target) const
+TestDataSrc::findCoveringNSEC3(const Name& zonename UNUSED_PARAM,
+                               string& hash UNUSED_PARAM,
+                               RRsetList& target UNUSED_PARAM) const
 {
     return (NOT_IMPLEMENTED);
 }

src/lib/auth/tests/test_datasrc.h

@@ -51,43 +51,37 @@ public:
     void findClosestEnclosure(NameMatch& match,
                               const isc::dns::RRClass& qclass) const;
 
-    Result findRRset(const Query& q,
-                     const isc::dns::Name& qname,
+    Result findRRset(const isc::dns::Name& qname,
                      const isc::dns::RRClass& qclass,
                      const isc::dns::RRType& qtype,
                      isc::dns::RRsetList& target,
                      uint32_t& flags,
                      const isc::dns::Name* zonename) const;
 
-    Result findExactRRset(const Query& q,
-                          const isc::dns::Name& qname,
+    Result findExactRRset(const isc::dns::Name& qname,
                           const isc::dns::RRClass& qclass,
                           const isc::dns::RRType& qtype,
                           isc::dns::RRsetList& target,
                           uint32_t& flags,
                           const isc::dns::Name* zonename) const;
 
-    Result findAddrs(const Query& q,
-                     const isc::dns::Name& qname,
+    Result findAddrs(const isc::dns::Name& qname,
                      const isc::dns::RRClass& qclass,
                      isc::dns::RRsetList& target,
                      uint32_t& flags,
                      const isc::dns::Name* zonename) const;
 
-    Result findReferral(const Query& q,
-                        const isc::dns::Name& qname,
+    Result findReferral(const isc::dns::Name& qname,
                         const isc::dns::RRClass& qclass,
                         isc::dns::RRsetList& target,
                         uint32_t& flags,
                         const isc::dns::Name* zonename) const;
 
-    Result findPreviousName(const Query& q,
-                            const isc::dns::Name& qname,
+    Result findPreviousName(const isc::dns::Name& qname,
                             isc::dns::Name& target,
                             const isc::dns::Name* zonename) const;
 
-    Result findCoveringNSEC3(const Query& q,
-                             const isc::dns::Name& zonename,
+    Result findCoveringNSEC3(const isc::dns::Name& zonename,
                              std::string& hash,
                              isc::dns::RRsetList& target) const;