It is rude for a test to crash

Make it fail nicely

git-svn-id: svn://bind10.isc.org/svn/bind10/branches/trac408@3690 e5f2f494-b856-4b98-b285-d166d9295462

src/lib/nsas/tests/nameserver_address_unittest.cc

@@ -30,6 +30,7 @@ namespace nsas {
 
 using namespace dns;
 using namespace rdata;
+using namespace boost;
 
 #define TEST_ADDRESS_INDEX 1
 
@@ -38,14 +39,18 @@ class NameserverEntrySample {
 public:
     NameserverEntrySample():
         name_("example.org"),
-        rrv4_(name_, RRClass::IN(), RRType::A(), RRTTL(1200))
+        rrv4_(new BasicRRset(name_, RRClass::IN(), RRType::A(), RRTTL(1200)))
     {
         // Add some sample A records
-        rrv4_.addRdata(ConstRdataPtr(new RdataTest<A>("1.2.3.4")));
-        rrv4_.addRdata(ConstRdataPtr(new RdataTest<A>("5.6.7.8")));
-        rrv4_.addRdata(ConstRdataPtr(new RdataTest<A>("9.10.11.12")));
+        rrv4_->addRdata(ConstRdataPtr(new RdataTest<A>("1.2.3.4")));
+        rrv4_->addRdata(ConstRdataPtr(new RdataTest<A>("5.6.7.8")));
+        rrv4_->addRdata(ConstRdataPtr(new RdataTest<A>("9.10.11.12")));
 
         ns_.reset(new NameserverEntry(name_.toText(), RRClass::IN()));
+        shared_ptr<TestResolver> resolver(new TestResolver);
+        ns_->askIP(resolver, shared_ptr<Callback>(new Callback), ANY_OK, ns_);
+        resolver->asksIPs(name_, 0, 1);
+        resolver->requests[0].second->success(rrv4_);
     }
 
     // Return the sample NameserverEntry
@@ -65,8 +70,13 @@ public:
 
 private:
     Name name_;                             ///< Name of the sample
-    BasicRRset rrv4_;                       ///< Standard RRSet - IN, A, lowercase name
+    shared_ptr<BasicRRset> rrv4_;           ///< Standard RRSet - IN, A, lowercase name
     boost::shared_ptr<NameserverEntry> ns_; ///< Shared_ptr that points to a NameserverEntry object
+
+    class Callback : public NameserverEntry::Callback {
+        public:
+            virtual void operator()(shared_ptr<NameserverEntry>) { }
+    };
 };
 
 /// \brief Test Fixture Class

src/lib/nsas/tests/nameserver_entry_unittest.cc

@@ -59,25 +59,18 @@ protected:
     };
 private:
     void fillSet(shared_ptr<TestResolver> resolver, size_t index,
-        const BasicRRset *set)
+        shared_ptr<BasicRRset> set)
     {
         if (set) {
-            shared_ptr<BasicRRset> new_set(new BasicRRset(set->getName(),
-                set->getClass(), set->getType(), set->getTTL()));
-            for(RdataIteratorPtr i(set->getRdataIterator()); !i->isLast();
-                i->next())
-            {
-                new_set->addRdata(i->getCurrent());
-            }
-            resolver->requests[index].second->success(new_set);
+            resolver->requests[index].second->success(set);
         } else {
             resolver->requests[index].second->failure();
         }
     }
 protected:
     /// Fills the nameserver entry with data trough ask IP
-    void fillNSEntry(shared_ptr<NameserverEntry> entry, const BasicRRset* rrv4,
-        const BasicRRset* rrv6)
+    void fillNSEntry(shared_ptr<NameserverEntry> entry,
+        shared_ptr<BasicRRset> rrv4, shared_ptr<BasicRRset> rrv6)
     {
         // Prepare data to run askIP
         shared_ptr<TestResolver> resolver(new TestResolver);
@@ -112,7 +105,7 @@ TEST_F(NameserverEntryTest, InitialRTT) {
     // Get the RTT for the different addresses
     shared_ptr<NameserverEntry> alpha(new NameserverEntry(EXAMPLE_CO_UK,
         RRClass::IN()));
-    fillNSEntry(alpha, &rrv4_, &rrv6_);
+    fillNSEntry(alpha, rrv4_, rrv6_);
     NameserverEntry::AddressVector vec;
     alpha->getAddresses(vec);
 
@@ -142,7 +135,7 @@ TEST_F(NameserverEntryTest, SetRTT) {
     // Get the RTT for the different addresses
     shared_ptr<NameserverEntry> alpha(new NameserverEntry(EXAMPLE_CO_UK,
         RRClass::IN()));
-    fillNSEntry(alpha, &rrv4_, &rrv6_);
+    fillNSEntry(alpha, rrv4_, rrv6_);
     NameserverEntry::AddressVector vec;
     alpha->getAddresses(vec);
 
@@ -177,7 +170,7 @@ TEST_F(NameserverEntryTest, Unreachable) {
     // Get the RTT for the different addresses
     shared_ptr<NameserverEntry> alpha(new NameserverEntry(EXAMPLE_CO_UK,
         RRClass::IN()));
-    fillNSEntry(alpha, &rrv4_, &rrv6_);
+    fillNSEntry(alpha, rrv4_, rrv6_);
     NameserverEntry::AddressVector vec;
     alpha->getAddresses(vec);
 
@@ -220,22 +213,22 @@ TEST_F(NameserverEntryTest, ExpirationTime) {
     // Test where there is a single TTL
     shared_ptr<NameserverEntry> alpha(new NameserverEntry(EXAMPLE_CO_UK,
         RRClass::IN()));
-    fillNSEntry(alpha, &rrv4_, NULL);
+    fillNSEntry(alpha, rrv4_, shared_ptr<BasicRRset>());
     expiration = alpha->getExpiration();
-    EXPECT_EQ(expiration, curtime + rrv4_.getTTL().getValue());
+    EXPECT_EQ(expiration, curtime + rrv4_->getTTL().getValue());
 
     shared_ptr<NameserverEntry> beta(new NameserverEntry(EXAMPLE_CO_UK,
         RRClass::IN()));
-    fillNSEntry(beta, NULL, &rrv6_);
+    fillNSEntry(beta, shared_ptr<BasicRRset>(), rrv6_);
     expiration = beta->getExpiration();
-    EXPECT_EQ(expiration, curtime + rrv6_.getTTL().getValue());
+    EXPECT_EQ(expiration, curtime + rrv6_->getTTL().getValue());
 
     // Test where there are two different TTLs
-    EXPECT_NE(rrv4_.getTTL().getValue(), rrv6_.getTTL().getValue());
+    EXPECT_NE(rrv4_->getTTL().getValue(), rrv6_->getTTL().getValue());
     shared_ptr<NameserverEntry> gamma(new NameserverEntry(EXAMPLE_CO_UK,
         RRClass::IN()));
-    fillNSEntry(gamma, &rrv4_, &rrv6_);
-    uint32_t minttl = min(rrv4_.getTTL().getValue(), rrv6_.getTTL().getValue());
+    fillNSEntry(gamma, rrv4_, rrv6_);
+    uint32_t minttl = min(rrv4_->getTTL().getValue(), rrv6_->getTTL().getValue());
     expiration = gamma->getExpiration();
     EXPECT_EQ(expiration, curtime + minttl);
 
@@ -245,8 +238,8 @@ TEST_F(NameserverEntryTest, ExpirationTime) {
 
     shared_ptr<NameserverEntry> delta(new NameserverEntry(EXAMPLE_CO_UK,
         RRClass::IN()));
-    fillNSEntry(gamma, &rrv4_, NULL);
-    EXPECT_GT(delta->getExpiration(), rrv4_.getTTL().getValue());
+    fillNSEntry(delta, rrv4_, shared_ptr<BasicRRset>());
+    EXPECT_GT(delta->getExpiration(), rrv4_->getTTL().getValue());
 }
 
 

src/lib/nsas/tests/nsas_test.h

@@ -235,8 +235,14 @@ class TestResolver : public isc::nsas::ResolverInterface {
         virtual void resolve(QuestionPtr q, CallbackPtr c) {
             requests.push_back(Request(q, c));
         }
+
+        // Thrown if the query at the given index does not exist.
+        class NoSuchRequest : public std::exception { };
+
         QuestionPtr operator[](size_t index) {
-            EXPECT_TRUE(checkIndex(index));
+            if (index >= requests.size()) {
+                throw NoSuchRequest();
+            }
             return (requests[index].first);
         }
         /*
@@ -276,6 +282,9 @@ class TestResolver : public isc::nsas::ResolverInterface {
         void answer(size_t index, const Name& name, const RRType& type,
             const rdata::Rdata& rdata, size_t TTL = 100)
         {
+            if (index >= requests.size()) {
+                throw NoSuchRequest();
+            }
             RRsetPtr set(new RRset(name, RRClass::IN(),
                 type, RRTTL(TTL)));
             set->addRdata(rdata);
@@ -290,24 +299,30 @@ static const std::string MIXED_EXAMPLE_CO_UK("EXAmple.co.uk.");
 
 class TestWithRdata : public ::testing::Test {
 protected:
+    typedef boost::shared_ptr<BasicRRset> BasicRRsetPtr;
     /// \brief Constructor
     ///
     /// Initializes the RRsets used in the tests.  The RRsets themselves have to
     /// be initialized with the basic data on their construction. The Rdata for
     /// them is added in SetUp().
     TestWithRdata() :
-        rrv4_(Name(EXAMPLE_CO_UK), RRClass::IN(), RRType::A(), RRTTL(1200)),
-        rrcase_(Name(MIXED_EXAMPLE_CO_UK), RRClass::IN(), RRType::A(),
-            RRTTL(1200)),
-        rrch_(Name(EXAMPLE_CO_UK), RRClass::CH(), RRType::A(), RRTTL(1200)),
-        rrns_(Name(EXAMPLE_CO_UK), RRClass::IN(), RRType::NS(), RRTTL(1200)),
-        rr_single_(Name(EXAMPLE_CO_UK), RRClass::IN(), RRType::NS(),
-            RRTTL(600)),
-        rr_empty_(Name(EXAMPLE_CO_UK), RRClass::IN(), RRType::NS(),
-            RRTTL(600)),
-        rrv6_(Name(EXAMPLE_CO_UK), RRClass::IN(), RRType::AAAA(), RRTTL(900)),
-        rrnet_(Name(EXAMPLE_NET), RRClass::IN(), RRType::A(), RRTTL(600)),
-        ns_name_(ns_name_)
+        rrv4_(new BasicRRset(Name(EXAMPLE_CO_UK), RRClass::IN(), RRType::A(),
+            RRTTL(1200))),
+        rrcase_(new BasicRRset(Name(MIXED_EXAMPLE_CO_UK), RRClass::IN(),
+            RRType::A(), RRTTL(1200))),
+        rrch_(new BasicRRset(Name(EXAMPLE_CO_UK), RRClass::CH(), RRType::A(),
+            RRTTL(1200))),
+        rrns_(new BasicRRset(Name(EXAMPLE_CO_UK), RRClass::IN(), RRType::NS(),
+            RRTTL(1200))),
+        rr_single_(new BasicRRset(Name(EXAMPLE_CO_UK), RRClass::IN(),
+            RRType::NS(), RRTTL(600))),
+        rr_empty_(new BasicRRset(Name(EXAMPLE_CO_UK), RRClass::IN(),
+            RRType::NS(), RRTTL(600))),
+        rrv6_(new BasicRRset(Name(EXAMPLE_CO_UK), RRClass::IN(),
+            RRType::AAAA(), RRTTL(900))),
+        rrnet_(new BasicRRset(Name(EXAMPLE_NET), RRClass::IN(), RRType::A(),
+            RRTTL(600))),
+        ns_name_("ns.example.net.")
     {}
 
     /// \brief Add Rdata to RRsets
@@ -317,42 +332,42 @@ protected:
     virtual void SetUp() {
 
         // A records
-        rrv4_.addRdata(ConstRdataPtr(new RdataTest<A>("1.2.3.4")));
-        rrv4_.addRdata(ConstRdataPtr(new RdataTest<A>("5.6.7.8")));
-        rrv4_.addRdata(ConstRdataPtr(new RdataTest<A>("9.10.11.12")));
+        rrv4_->addRdata(ConstRdataPtr(new RdataTest<A>("1.2.3.4")));
+        rrv4_->addRdata(ConstRdataPtr(new RdataTest<A>("5.6.7.8")));
+        rrv4_->addRdata(ConstRdataPtr(new RdataTest<A>("9.10.11.12")));
 
         // A records
-        rrcase_.addRdata(ConstRdataPtr(new RdataTest<A>("13.14.15.16")));
+        rrcase_->addRdata(ConstRdataPtr(new RdataTest<A>("13.14.15.16")));
 
         // No idea what Chaosnet address look like other than they are 16 bits
         // The fact that they are type A is probably also incorrect.
-        rrch_.addRdata(ConstRdataPtr(new RdataTest<A>("1324")));
+        rrch_->addRdata(ConstRdataPtr(new RdataTest<A>("1324")));
 
         // NS records take a single name
-        rrns_.addRdata(ConstRdataPtr(new RdataTest<NS>("example.fr")));
-        rrns_.addRdata(ConstRdataPtr(new RdataTest<NS>("example.de")));
+        rrns_->addRdata(ConstRdataPtr(new RdataTest<NS>("example.fr")));
+        rrns_->addRdata(ConstRdataPtr(new RdataTest<NS>("example.de")));
 
         // Single NS record with 0 TTL
-        rr_single_.addRdata(ConstRdataPtr(new RdataTest<NS>(
+        rr_single_->addRdata(ConstRdataPtr(new RdataTest<NS>(
             "ns.example.net.")));
 
         // AAAA records
-        rrv6_.addRdata(ConstRdataPtr(new RdataTest<AAAA>("2001::1002")));
-        rrv6_.addRdata(ConstRdataPtr(new RdataTest<AAAA>("dead:beef:feed::")));
+        rrv6_->addRdata(ConstRdataPtr(new RdataTest<AAAA>("2001::1002")));
+        rrv6_->addRdata(ConstRdataPtr(new RdataTest<AAAA>("dead:beef:feed::")));
 
         // A record for example.net
-        rrnet_.addRdata(ConstRdataPtr(new RdataTest<A>("17.18.18.20")));
+        rrnet_->addRdata(ConstRdataPtr(new RdataTest<A>("17.18.18.20")));
     }
 
     /// \brief Data for the tests
-    BasicRRset rrv4_;           ///< Standard RRSet - IN, A, lowercase name
-    BasicRRset rrcase_;         ///< Mixed-case name
-    BasicRRset rrch_;           ///< Non-IN RRset (Chaos in this case)
-    BasicRRset rrns_;           ///< NS RRset
-    BasicRRset rr_single_;      ///< NS RRset with single NS
-    BasicRRset rr_empty_;       ///< NS RRset without any nameservers
-    BasicRRset rrv6_;           ///< Standard RRset, IN, AAAA, lowercase name
-    BasicRRset rrnet_;          ///< example.net A RRset
+    BasicRRsetPtr rrv4_;           ///< Standard RRSet - IN, A, lowercase name
+    BasicRRsetPtr rrcase_;         ///< Mixed-case name
+    BasicRRsetPtr rrch_;           ///< Non-IN RRset (Chaos in this case)
+    BasicRRsetPtr rrns_;           ///< NS RRset
+    BasicRRsetPtr rr_single_;      ///< NS RRset with single NS
+    BasicRRsetPtr rr_empty_;       ///< NS RRset without any nameservers
+    BasicRRsetPtr rrv6_;           ///< Standard RRset, IN, AAAA, lowercase name
+    BasicRRsetPtr rrnet_;          ///< example.net A RRset
     Name ns_name_;  ///< Nameserver name of ns.example.net
 };
 

src/lib/nsas/tests/zone_entry_unittest.cc

@@ -99,8 +99,9 @@ TEST_F(ZoneEntryTest, DefaultConstructor) {
 }
 
 /// Tests of constructor from referral data
-TEST_F(ZoneEntryTest, ReferralConstructor) {
-    InheritedZoneEntry alpha(resolver_, rr_single_, nameserver_table_,
+/// Disabled, as this one will probably go away soon
+TEST_F(ZoneEntryTest, DISABLED_ReferralConstructor) {
+    InheritedZoneEntry alpha(resolver_, *rr_single_, nameserver_table_,
         nameserver_lru_);
     // It should load the name and class from the referral info
     EXPECT_EQ(EXAMPLE_CO_UK, alpha.getName());
@@ -113,7 +114,7 @@ TEST_F(ZoneEntryTest, ReferralConstructor) {
 // It should answer negatively right away if there are no nameservers
 TEST_F(ZoneEntryTest, CallbackNoNS) {
     shared_ptr<InheritedZoneEntry> zone(new InheritedZoneEntry(resolver_,
-        rr_empty_, nameserver_table_, nameserver_lru_));
+        *rr_empty_, nameserver_table_, nameserver_lru_));
     // It should accept the callback
     EXPECT_TRUE(zone->addCallback(callback_, ANY_OK, zone));
     // And tell imediatelly that it is unreachable (when it has no nameservers)
@@ -124,9 +125,9 @@ TEST_F(ZoneEntryTest, CallbackNoNS) {
 // Check it accepts the first callback with 0 TTL
 TEST_F(ZoneEntryTest, CallbackZeroTTL) {
     // Make it zero TTL, so it expires right away
-    rr_single_.setTTL(RRTTL(0));
+    rr_single_->setTTL(RRTTL(0));
     shared_ptr<InheritedZoneEntry> zone(new InheritedZoneEntry(resolver_,
-        rr_single_, nameserver_table_, nameserver_lru_));
+        *rr_single_, nameserver_table_, nameserver_lru_));
     // It should accept the callback
     EXPECT_TRUE(zone->addCallback(callback_, ANY_OK, zone));
     // It should not be answered yet, it should ask for the IP addresses
@@ -140,7 +141,7 @@ TEST_F(ZoneEntryTest, CallbackZeroTTL) {
 // Check it answers callbacks when we give it addresses
 TEST_F(ZoneEntryTest, CallbacksAnswered) {
     shared_ptr<InheritedZoneEntry> zone(new InheritedZoneEntry(resolver_,
-        rr_single_, nameserver_table_, nameserver_lru_));
+        *rr_single_, nameserver_table_, nameserver_lru_));
     // It should be in NOT_ASKED state
     EXPECT_EQ(Fetchable::NOT_ASKED, zone->getState());
     // It should accept the callback
@@ -156,7 +157,8 @@ TEST_F(ZoneEntryTest, CallbacksAnswered) {
     EXPECT_TRUE(zone->addCallback(callback_, V6_ONLY, zone));
     // Nothing more is asked
     EXPECT_EQ(2, resolver_->requests.size());
-    resolver_->answer(0, ns_name_, RRType::A(), rdata::in::A("192.0.2.1"));
+    EXPECT_NO_THROW(resolver_->answer(0, ns_name_, RRType::A(),
+         rdata::in::A("192.0.2.1")));
     // Two are answered (ANY and V4)
     ASSERT_EQ(2, callback_->successes_.size());
     EXPECT_TRUE(IOAddress("192.0.2.1").equal(callback_->successes_[0]));
@@ -165,8 +167,8 @@ TEST_F(ZoneEntryTest, CallbacksAnswered) {
     EXPECT_EQ(0, callback_->unreachable_count_);
     // We are still in progress, not everything arrived
     EXPECT_EQ(Fetchable::IN_PROGRESS, zone->getState());
-    resolver_->answer(1, ns_name_, RRType::AAAA(),
-        rdata::in::AAAA("2001:db8::1"));
+    EXPECT_NO_THROW(resolver_->answer(1, ns_name_, RRType::AAAA(),
+        rdata::in::AAAA("2001:db8::1")));
     // This should answer the third callback
     ASSERT_EQ(3, callback_->successes_.size());
     EXPECT_TRUE(IOAddress("2001:db8::1").equal(callback_->successes_[2]));
@@ -184,7 +186,7 @@ TEST_F(ZoneEntryTest, CallbacksAnswered) {
 // Pretend the server can be reached only by IPv4
 TEST_F(ZoneEntryTest, CallbacksAOnly) {
     shared_ptr<InheritedZoneEntry> zone(new InheritedZoneEntry(resolver_,
-        rr_single_, nameserver_table_, nameserver_lru_));
+        *rr_single_, nameserver_table_, nameserver_lru_));
     // It should be in NOT_ASKED state
     EXPECT_EQ(Fetchable::NOT_ASKED, zone->getState());
     // It should accept the callback
@@ -198,6 +200,7 @@ TEST_F(ZoneEntryTest, CallbacksAOnly) {
     // Give two more callbacks, with different address families
     EXPECT_TRUE(zone->addCallback(callback_, V4_ONLY, zone));
     EXPECT_TRUE(zone->addCallback(callback_, V6_ONLY, zone));
+    ASSERT_GE(resolver_->requests.size(), 2);
     resolver_->requests[1].second->failure();
     // One should be rejected, but two still stay, they have chance
     EXPECT_EQ(0, callback_->successes_.size());
@@ -205,7 +208,8 @@ TEST_F(ZoneEntryTest, CallbacksAOnly) {
     EXPECT_EQ(Fetchable::IN_PROGRESS, zone->getState());
     // Answer the A one and see it answers what can be answered
     ASSERT_EQ(2, callback_->successes_.size());
-    resolver_->answer(0, ns_name_, RRType::A(), rdata::in::A("192.0.2.1"));
+    EXPECT_NO_THROW(resolver_->answer(0, ns_name_, RRType::A(),
+        rdata::in::A("192.0.2.1")));
     EXPECT_TRUE(IOAddress("192.0.2.1").equal(callback_->successes_[0]));
     EXPECT_TRUE(IOAddress("192.0.2.1").equal(callback_->successes_[1]));
     EXPECT_EQ(1, callback_->unreachable_count_);
@@ -227,14 +231,16 @@ TEST_F(ZoneEntryTest, CallbacksAOnly) {
 // See it tries hard enough to get address and tries both nameservers
 TEST_F(ZoneEntryTest, CallbackTwoNS) {
     shared_ptr<InheritedZoneEntry> zone(new InheritedZoneEntry(resolver_,
-        rrns_, nameserver_table_, nameserver_lru_));
+        *rrns_, nameserver_table_, nameserver_lru_));
     // It should be in NOT_ASKED state
     EXPECT_EQ(Fetchable::NOT_ASKED, zone->getState());
     // It should accept the callback
     EXPECT_TRUE(zone->addCallback(callback_, V4_ONLY, zone));
     EXPECT_EQ(Fetchable::IN_PROGRESS, zone->getState());
     // It asks a question (we do not know which nameserver)
-    resolver_->asksIPs((*resolver_)[0]->getName(), 0, 1);
+    shared_ptr<Name> name;
+    ASSERT_NO_THROW(name.reset(new Name((*resolver_)[0]->getName())));
+    ASSERT_TRUE(resolver_->asksIPs(*name, 0, 1));
     resolver_->requests[0].second->failure();
     // Nothing should be answered or failed yet
     EXPECT_EQ(0, callback_->unreachable_count_);
@@ -242,7 +248,7 @@ TEST_F(ZoneEntryTest, CallbackTwoNS) {
     // It should be still IN_PROGRESS and ask the second nameserver
     // (at last now, if not before)
     EXPECT_EQ(Fetchable::IN_PROGRESS, zone->getState());
-    resolver_->asksIPs((*resolver_)[2]->getName(), 2, 3);
+    ASSERT_TRUE(resolver_->asksIPs((*resolver_)[2]->getName(), 2, 3));
     // Fail the second one
     resolver_->requests[2].second->failure();
     // The callback should be failed now, as there is no chance of getting
@@ -265,8 +271,8 @@ TEST_F(ZoneEntryTest, CallbackTwoNS) {
     EXPECT_EQ(2, callback_->unreachable_count_);
     EXPECT_EQ(0, callback_->successes_.size());
     // Answer the IPv6 one
-    resolver_->answer(1, (*resolver_)[1]->getName(), RRType::AAAA(),
-        rdata::in::AAAA("2001:db8::1"));
+    EXPECT_NO_THROW(resolver_->answer(1, (*resolver_)[1]->getName(),
+        RRType::AAAA(), rdata::in::AAAA("2001:db8::1")));
 
     // Ready, as we have at last some address
     EXPECT_EQ(Fetchable::READY, zone->getState());