3.30/doxygen/ipv4-rip-test_8cc_source.html

 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
  * Copyright (c) 2016 Universita' di Firenze
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  * Author: Tommaso Pecorella <tommaso.pecorella@unifi.it>
  */

 #include "ns3/test.h"
 #include "ns3/socket-factory.h"
 #include "ns3/udp-socket-factory.h"
 #include "ns3/simulator.h"
 #include "ns3/simple-channel.h"
 #include "ns3/simple-net-device.h"
 #include "ns3/socket.h"
 #include "ns3/boolean.h"
 #include "ns3/enum.h"

 #include "ns3/log.h"
 #include "ns3/node.h"
 #include "ns3/inet-socket-address.h"

 #include "ns3/internet-stack-helper.h"
 #include "ns3/ipv4-address-helper.h"
 #include "ns3/ipv4-l3-protocol.h"
 #include "ns3/icmpv4-l4-protocol.h"
 #include "ns3/udp-l4-protocol.h"
 #include "ns3/rip.h"
 #include "ns3/rip-helper.h"
 #include "ns3/node-container.h"
 #include "ns3/ipv4-static-routing.h"

 #include <string>
 #include <limits>

 using namespace ns3;

 class Ipv4RipTest : public TestCase
 {
   Ptr<Packet> m_receivedPacket;

   void DoSendData (Ptr<Socket> socket, std::string to);
   void SendData (Ptr<Socket> socket, std::string to);

 public:
   virtual void DoRun (void);
   Ipv4RipTest ();

   void ReceivePkt (Ptr<Socket> socket);
 };

 Ipv4RipTest::Ipv4RipTest ()
   : TestCase ("RIP")
 {
 }

 void Ipv4RipTest::ReceivePkt (Ptr<Socket> socket)
 {
   uint32_t availableData;
   availableData = socket->GetRxAvailable ();
   m_receivedPacket = socket->Recv (std::numeric_limits<uint32_t>::max (), 0);
   NS_ASSERT (availableData == m_receivedPacket->GetSize ());
   //cast availableData to void, to suppress 'availableData' set but not used
   //compiler warning
   (void) availableData;
 }

 void
 Ipv4RipTest::DoSendData (Ptr<Socket> socket, std::string to)
 {
   Address realTo = InetSocketAddress (Ipv4Address (to.c_str ()), 1234);
   NS_TEST_EXPECT_MSG_EQ (socket->SendTo (Create<Packet> (123), 0, realTo),
                          123, "100");
 }

 void
 Ipv4RipTest::SendData (Ptr<Socket> socket, std::string to)
 {
   m_receivedPacket = Create<Packet> ();
   Simulator::ScheduleWithContext (socket->GetNode ()->GetId (), Seconds (60),
                                   &Ipv4RipTest::DoSendData, this, socket, to);
   Simulator::Stop (Seconds (66));
   Simulator::Run ();
 }

 void
 Ipv4RipTest::DoRun (void)
 {
   // Create topology

   Ptr<Node> txNode = CreateObject<Node> ();
   Ptr<Node> rxNode = CreateObject<Node> ();
   Ptr<Node> routerA = CreateObject<Node> ();
   Ptr<Node> routerB = CreateObject<Node> ();
   Ptr<Node> routerC = CreateObject<Node> ();

   NodeContainer nodes (txNode, rxNode);
   NodeContainer routers (routerA, routerB, routerC);
   NodeContainer all (nodes, routers);

   RipHelper ripRouting;
   InternetStackHelper internetRouters;
   internetRouters.SetRoutingHelper (ripRouting);
   internetRouters.Install (routers);

   InternetStackHelper internetNodes;
   internetNodes.Install (nodes);

   NetDeviceContainer net1;
   NetDeviceContainer net2;
   NetDeviceContainer net3;
   NetDeviceContainer net4;

   // Sender Node
   Ptr<SimpleNetDevice> txDev;
   {
     txDev = CreateObject<SimpleNetDevice> ();
     txDev->SetAddress (Mac48Address ("00:00:00:00:00:01"));
     txNode->AddDevice (txDev);
   }
   net1.Add (txDev);

   // Router A
   Ptr<SimpleNetDevice> fwDev1routerA, fwDev2routerA;
   { // first interface
     fwDev1routerA = CreateObject<SimpleNetDevice> ();
     fwDev1routerA->SetAddress (Mac48Address ("00:00:00:00:00:02"));
     routerA->AddDevice (fwDev1routerA);
   }
   net1.Add (fwDev1routerA);

   { // second interface
     fwDev2routerA = CreateObject<SimpleNetDevice> ();
     fwDev2routerA->SetAddress (Mac48Address ("00:00:00:00:00:03"));
     routerA->AddDevice (fwDev2routerA);
   }
   net2.Add (fwDev2routerA);

   // Router B
   Ptr<SimpleNetDevice> fwDev1routerB, fwDev2routerB;
   { // first interface
     fwDev1routerB = CreateObject<SimpleNetDevice> ();
     fwDev1routerB->SetAddress (Mac48Address ("00:00:00:00:00:04"));
     routerB->AddDevice (fwDev1routerB);
   }
   net2.Add (fwDev1routerB);

   { // second interface
     fwDev2routerB = CreateObject<SimpleNetDevice> ();
     fwDev2routerB->SetAddress (Mac48Address ("00:00:00:00:00:05"));
     routerB->AddDevice (fwDev2routerB);
   }
   net3.Add (fwDev2routerB);

   // Router C
   Ptr<SimpleNetDevice> fwDev1routerC, fwDev2routerC;
   { // first interface
     fwDev1routerC = CreateObject<SimpleNetDevice> ();
     fwDev1routerC->SetAddress (Mac48Address ("00:00:00:00:00:06"));
     routerC->AddDevice (fwDev1routerC);
   }
   net3.Add (fwDev1routerC);

   { // second interface
     fwDev2routerC = CreateObject<SimpleNetDevice> ();
     fwDev2routerC->SetAddress (Mac48Address ("00:00:00:00:00:07"));
     routerC->AddDevice (fwDev2routerC);
   }
   net4.Add (fwDev2routerC);

   // Rx node
   Ptr<SimpleNetDevice> rxDev;
   { // first interface
     rxDev = CreateObject<SimpleNetDevice> ();
     rxDev->SetAddress (Mac48Address ("00:00:00:00:00:08"));
     rxNode->AddDevice (rxDev);
   }
   net4.Add (rxDev);

   // link the channels
   Ptr<SimpleChannel> channel1 = CreateObject<SimpleChannel> ();
   txDev->SetChannel (channel1);
   fwDev1routerA->SetChannel (channel1);

   Ptr<SimpleChannel> channel2 = CreateObject<SimpleChannel> ();
   fwDev2routerA->SetChannel (channel2);
   fwDev1routerB->SetChannel (channel2);

   Ptr<SimpleChannel> channel3 = CreateObject<SimpleChannel> ();
   fwDev2routerB->SetChannel (channel3);
   fwDev1routerC->SetChannel (channel3);

   Ptr<SimpleChannel> channel4 = CreateObject<SimpleChannel> ();
   fwDev2routerC->SetChannel (channel4);
   rxDev->SetChannel (channel4);

   // Setup IPv4 addresses and forwarding
   Ipv4AddressHelper ipv4;

   ipv4.SetBase (Ipv4Address ("10.0.1.0"), Ipv4Mask ("255.255.255.0"));
   Ipv4InterfaceContainer iic1 = ipv4.Assign (net1);

   ipv4.SetBase (Ipv4Address ("192.168.0.0"), Ipv4Mask ("255.255.255.0"));
   Ipv4InterfaceContainer iic2 = ipv4.Assign (net2);

   ipv4.SetBase (Ipv4Address ("192.168.1.0"), Ipv4Mask ("255.255.255.0"));
   Ipv4InterfaceContainer iic3 = ipv4.Assign (net3);

   ipv4.SetBase (Ipv4Address ("10.0.2.0"), Ipv4Mask ("255.255.255.0"));
   Ipv4InterfaceContainer iic4 = ipv4.Assign (net4);

   Ptr<Ipv4StaticRouting> staticRouting;
   staticRouting = Ipv4RoutingHelper::GetRouting <Ipv4StaticRouting> (txNode->GetObject<Ipv4> ()->GetRoutingProtocol ());
   staticRouting->SetDefaultRoute ("10.0.1.2", 1 );
   staticRouting = Ipv4RoutingHelper::GetRouting <Ipv4StaticRouting> (rxNode->GetObject<Ipv4> ()->GetRoutingProtocol ());
   staticRouting->SetDefaultRoute ("10.0.2.1", 1 );

   // Create the UDP sockets
   Ptr<SocketFactory> rxSocketFactory = rxNode->GetObject<UdpSocketFactory> ();
   Ptr<Socket> rxSocket = rxSocketFactory->CreateSocket ();
   NS_TEST_EXPECT_MSG_EQ (rxSocket->Bind (InetSocketAddress (Ipv4Address ("10.0.2.2"), 1234)), 0, "trivial");
   rxSocket->SetRecvCallback (MakeCallback (&Ipv4RipTest::ReceivePkt, this));

   Ptr<SocketFactory> txSocketFactory = txNode->GetObject<UdpSocketFactory> ();
   Ptr<Socket> txSocket = txSocketFactory->CreateSocket ();
   txSocket->SetAllowBroadcast (true);

   // ------ Now the tests ------------

   // Unicast test
   SendData (txSocket, "10.0.2.2");
   NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 123, "IPv4 RIP should work.");

   m_receivedPacket->RemoveAllByteTags ();

   Simulator::Destroy ();
 }


 class Ipv4RipCountToInfinityTest : public TestCase
 {
   Ptr<Packet> m_receivedPacket;

   void DoSendData (Ptr<Socket> socket, std::string to);
   void SendData (Ptr<Socket> socket, std::string to);

 public:
   virtual void DoRun (void);
   Ipv4RipCountToInfinityTest ();

   void ReceivePkt (Ptr<Socket> socket);
 };

 Ipv4RipCountToInfinityTest::Ipv4RipCountToInfinityTest ()
   : TestCase ("RIP counting to infinity")
 {
 }

 void Ipv4RipCountToInfinityTest::ReceivePkt (Ptr<Socket> socket)
 {
   uint32_t availableData;
   availableData = socket->GetRxAvailable ();
   m_receivedPacket = socket->Recv (std::numeric_limits<uint32_t>::max (), 0);
   NS_ASSERT (availableData == m_receivedPacket->GetSize ());
   //cast availableData to void, to suppress 'availableData' set but not used
   //compiler warning
   (void) availableData;
 }

 void
 Ipv4RipCountToInfinityTest::DoSendData (Ptr<Socket> socket, std::string to)
 {
   Address realTo = InetSocketAddress (Ipv4Address (to.c_str ()), 1234);
   NS_TEST_EXPECT_MSG_EQ (socket->SendTo (Create<Packet> (123), 0, realTo),
                          123, "100");
 }

 void
 Ipv4RipCountToInfinityTest::SendData (Ptr<Socket> socket, std::string to)
 {
   m_receivedPacket = Create<Packet> ();
   Simulator::ScheduleWithContext (socket->GetNode ()->GetId (), Seconds (60),
                                   &Ipv4RipCountToInfinityTest::DoSendData, this, socket, to);
   Simulator::Stop (Seconds (66));
   Simulator::Run ();
 }

 void
 Ipv4RipCountToInfinityTest::DoRun (void)
 {
   // Create topology

   Ptr<Node> txNode = CreateObject<Node> ();
   Ptr<Node> rxNode = CreateObject<Node> ();
   Ptr<Node> routerA = CreateObject<Node> ();
   Ptr<Node> routerB = CreateObject<Node> ();
   Ptr<Node> routerC = CreateObject<Node> ();

   NodeContainer nodes (txNode, rxNode);
   NodeContainer routers (routerA, routerB, routerC);
   NodeContainer all (nodes, routers);

   RipHelper ripNgRouting;
   // Change the router's interface metric to 10, must not send packets (count to infinity)
   // note: Interface 0 is the loopback.
   ripNgRouting.SetInterfaceMetric (routerA, 2, 10);
   ripNgRouting.SetInterfaceMetric (routerB, 1, 10);
   ripNgRouting.SetInterfaceMetric (routerB, 2, 10);
   ripNgRouting.SetInterfaceMetric (routerC, 1, 10);

   InternetStackHelper internetv6routers;
   internetv6routers.SetRoutingHelper (ripNgRouting);
   internetv6routers.Install (routers);

   InternetStackHelper internetv6nodes;
   internetv6nodes.Install (nodes);

   NetDeviceContainer net1;
   NetDeviceContainer net2;
   NetDeviceContainer net3;
   NetDeviceContainer net4;

   // Sender Node
   Ptr<SimpleNetDevice> txDev;
   {
     txDev = CreateObject<SimpleNetDevice> ();
     txDev->SetAddress (Mac48Address ("00:00:00:00:00:01"));
     txNode->AddDevice (txDev);
   }
   net1.Add (txDev);

   // Router A
   Ptr<SimpleNetDevice> fwDev1routerA, fwDev2routerA;
   { // first interface
     fwDev1routerA = CreateObject<SimpleNetDevice> ();
     fwDev1routerA->SetAddress (Mac48Address ("00:00:00:00:00:02"));
     routerA->AddDevice (fwDev1routerA);
   }
   net1.Add (fwDev1routerA);

   { // second interface
     fwDev2routerA = CreateObject<SimpleNetDevice> ();
     fwDev2routerA->SetAddress (Mac48Address ("00:00:00:00:00:03"));
     routerA->AddDevice (fwDev2routerA);
   }
   net2.Add (fwDev2routerA);

   // Router B
   Ptr<SimpleNetDevice> fwDev1routerB, fwDev2routerB;
   { // first interface
     fwDev1routerB = CreateObject<SimpleNetDevice> ();
     fwDev1routerB->SetAddress (Mac48Address ("00:00:00:00:00:04"));
     routerB->AddDevice (fwDev1routerB);
   }
   net2.Add (fwDev1routerB);

   { // second interface
     fwDev2routerB = CreateObject<SimpleNetDevice> ();
     fwDev2routerB->SetAddress (Mac48Address ("00:00:00:00:00:05"));
     routerB->AddDevice (fwDev2routerB);
   }
   net3.Add (fwDev2routerB);

   // Router C
   Ptr<SimpleNetDevice> fwDev1routerC, fwDev2routerC;
   { // first interface
     fwDev1routerC = CreateObject<SimpleNetDevice> ();
     fwDev1routerC->SetAddress (Mac48Address ("00:00:00:00:00:06"));
     routerC->AddDevice (fwDev1routerC);
   }
   net3.Add (fwDev1routerC);

   { // second interface
     fwDev2routerC = CreateObject<SimpleNetDevice> ();
     fwDev2routerC->SetAddress (Mac48Address ("00:00:00:00:00:07"));
     routerC->AddDevice (fwDev2routerC);
   }
   net4.Add (fwDev2routerC);

   // Rx node
   Ptr<SimpleNetDevice> rxDev;
   { // first interface
     rxDev = CreateObject<SimpleNetDevice> ();
     rxDev->SetAddress (Mac48Address ("00:00:00:00:00:08"));
     rxNode->AddDevice (rxDev);
   }
   net4.Add (rxDev);

   // link the channels
   Ptr<SimpleChannel> channel1 = CreateObject<SimpleChannel> ();
   txDev->SetChannel (channel1);
   fwDev1routerA->SetChannel (channel1);

   Ptr<SimpleChannel> channel2 = CreateObject<SimpleChannel> ();
   fwDev2routerA->SetChannel (channel2);
   fwDev1routerB->SetChannel (channel2);

   Ptr<SimpleChannel> channel3 = CreateObject<SimpleChannel> ();
   fwDev2routerB->SetChannel (channel3);
   fwDev1routerC->SetChannel (channel3);

   Ptr<SimpleChannel> channel4 = CreateObject<SimpleChannel> ();
   fwDev2routerC->SetChannel (channel4);
   rxDev->SetChannel (channel4);

   // Setup IPv4 addresses and forwarding
   Ipv4AddressHelper ipv4;

   ipv4.SetBase (Ipv4Address ("10.0.1.0"), Ipv4Mask ("255.255.255.0"));
   Ipv4InterfaceContainer iic1 = ipv4.Assign (net1);

   ipv4.SetBase (Ipv4Address ("192.168.0.0"), Ipv4Mask ("255.255.255.0"));
   Ipv4InterfaceContainer iic2 = ipv4.Assign (net2);

   ipv4.SetBase (Ipv4Address ("192.168.1.0"), Ipv4Mask ("255.255.255.0"));
   Ipv4InterfaceContainer iic3 = ipv4.Assign (net3);

   ipv4.SetBase (Ipv4Address ("10.0.2.0"), Ipv4Mask ("255.255.255.0"));
   Ipv4InterfaceContainer iic4 = ipv4.Assign (net4);

   Ptr<Ipv4StaticRouting> staticRouting;
   staticRouting = Ipv4RoutingHelper::GetRouting <Ipv4StaticRouting> (txNode->GetObject<Ipv4> ()->GetRoutingProtocol ());
   staticRouting->SetDefaultRoute ("10.0.1.2", 1 );
   staticRouting = Ipv4RoutingHelper::GetRouting <Ipv4StaticRouting> (rxNode->GetObject<Ipv4> ()->GetRoutingProtocol ());
   staticRouting->SetDefaultRoute ("10.0.2.1", 1 );


   // Create the UDP sockets
   Ptr<SocketFactory> rxSocketFactory = rxNode->GetObject<UdpSocketFactory> ();
   Ptr<Socket> rxSocket = rxSocketFactory->CreateSocket ();
   NS_TEST_EXPECT_MSG_EQ (rxSocket->Bind (InetSocketAddress (Ipv4Address ("10.0.2.2"), 1234)), 0, "trivial");
   rxSocket->SetRecvCallback (MakeCallback (&Ipv4RipCountToInfinityTest::ReceivePkt, this));

   Ptr<SocketFactory> txSocketFactory = txNode->GetObject<UdpSocketFactory> ();
   Ptr<Socket> txSocket = txSocketFactory->CreateSocket ();
   txSocket->SetAllowBroadcast (true);

   // ------ Now the tests ------------

   SendData (txSocket, "10.0.2.2");
   NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 0, "RIP counting to infinity.");

   Simulator::Destroy ();
 }


 class Ipv4RipSplitHorizonStrategyTest : public TestCase
 {
   Rip::SplitHorizonType_e m_setStrategy;
   Rip::SplitHorizonType_e m_detectedStrategy;

 public:
   virtual void DoRun (void);

   Ipv4RipSplitHorizonStrategyTest (Rip::SplitHorizonType_e strategy);

   void ReceivePktProbe (Ptr<Socket> socket);
 };

 Ipv4RipSplitHorizonStrategyTest::Ipv4RipSplitHorizonStrategyTest (Rip::SplitHorizonType_e strategy)
   : TestCase ("RIP Split Horizon strategy")
 {
   m_setStrategy = strategy;
 }

 void Ipv4RipSplitHorizonStrategyTest::ReceivePktProbe (Ptr<Socket> socket)
 {
   uint32_t availableData;
   availableData = socket->GetRxAvailable ();
   Address srcAddr;
   Ptr<Packet> receivedPacketProbe = socket->RecvFrom (std::numeric_limits<uint32_t>::max (), 0, srcAddr);
   NS_ASSERT (availableData == receivedPacketProbe->GetSize ());
   Ipv4Address senderAddress = InetSocketAddress::ConvertFrom (srcAddr).GetIpv4 ();

   if (senderAddress == "192.168.0.2")
     {
       RipHeader hdr;
       receivedPacketProbe->RemoveHeader (hdr);

       std::list<RipRte> rtes = hdr.GetRteList ();

       // validate the RTEs before processing
       for (std::list<RipRte>::iterator iter = rtes.begin ();
           iter != rtes.end (); iter++)
         {
           if (iter->GetPrefix () == "10.0.1.0")
             {
               bool correct = false;
               if (iter->GetRouteMetric () == 16)
                 {
                   correct = true;
                   m_detectedStrategy = Rip::POISON_REVERSE;
                 }
               else if (iter->GetRouteMetric () == 2)
                 {
                   correct = true;
                   m_detectedStrategy = Rip::NO_SPLIT_HORIZON;
                 }
               NS_TEST_EXPECT_MSG_EQ (correct, true, "RIP: unexpected metric value: " << iter->GetRouteMetric ());
             }
         }
     }

   //cast availableData to void, to suppress 'availableData' set but not used
   //compiler warning
   (void) availableData;
 }

 void
 Ipv4RipSplitHorizonStrategyTest::DoRun (void)
 {
   // Create topology

   Ptr<Node> fakeNode = CreateObject<Node> ();
   Ptr<Node> listener = CreateObject<Node> ();

   Ptr<Node> routerA = CreateObject<Node> ();
   Ptr<Node> routerB = CreateObject<Node> ();

   NodeContainer listeners (listener, fakeNode);
   NodeContainer routers (routerA, routerB);
   NodeContainer all (routers, listeners);

   RipHelper ripNgRouting;
   ripNgRouting.Set ("SplitHorizon", EnumValue (m_setStrategy));

   InternetStackHelper internetRouters;
   internetRouters.SetRoutingHelper (ripNgRouting);
   internetRouters.Install (routers);

   InternetStackHelper internetNodes;
   internetNodes.Install (listeners);

   NetDeviceContainer net0;
   NetDeviceContainer net1;

   // Fake Node
   Ptr<SimpleNetDevice> silentDev;
   {
     silentDev = CreateObject<SimpleNetDevice> ();
     silentDev->SetAddress (Mac48Address ("00:00:00:00:00:01"));
     fakeNode->AddDevice (silentDev);
   }
   net0.Add (silentDev);

   // Router A
   Ptr<SimpleNetDevice> silentDevRouterA, fwDevRouterA;
   { // silent interface
     silentDevRouterA = CreateObject<SimpleNetDevice> ();
     silentDevRouterA->SetAddress (Mac48Address ("00:00:00:00:00:02"));
     routerA->AddDevice (silentDevRouterA);
   }
   net0.Add (silentDevRouterA);

   { // first interface
     fwDevRouterA = CreateObject<SimpleNetDevice> ();
     fwDevRouterA->SetAddress (Mac48Address ("00:00:00:00:00:03"));
     routerA->AddDevice (fwDevRouterA);
   }
   net1.Add (fwDevRouterA);

   // Router B
   Ptr<SimpleNetDevice> fwDevRouterB;
   { // first interface
     fwDevRouterB = CreateObject<SimpleNetDevice> ();
     fwDevRouterB->SetAddress (Mac48Address ("00:00:00:00:00:04"));
     routerB->AddDevice (fwDevRouterB);
   }
   net1.Add (fwDevRouterB);

   // listener A
   Ptr<SimpleNetDevice> listenerDev;
   {
     listenerDev = CreateObject<SimpleNetDevice> ();
     listenerDev->SetAddress (Mac48Address ("00:00:00:00:00:05"));
     listener->AddDevice (listenerDev);
   }
   net1.Add (listenerDev);

   // link the channels
   Ptr<SimpleChannel> channel0 = CreateObject<SimpleChannel> ();
   silentDev->SetChannel (channel0);
   silentDevRouterA->SetChannel (channel0);

   Ptr<SimpleChannel> channel1 = CreateObject<SimpleChannel> ();
   fwDevRouterA->SetChannel (channel1);
   fwDevRouterB->SetChannel (channel1);
   listenerDev->SetChannel (channel1);

   // Setup IPv6 addresses and forwarding
   Ipv4AddressHelper ipv4;

   ipv4.SetBase (Ipv4Address ("10.0.1.0"), Ipv4Mask ("255.255.255.0"));
   Ipv4InterfaceContainer iic0 = ipv4.Assign (net0);

   ipv4.SetBase (Ipv4Address ("192.168.0.0"), Ipv4Mask ("255.255.255.0"));
   Ipv4InterfaceContainer iic1 = ipv4.Assign (net1);

   // Create the UDP sockets
   Ptr<SocketFactory> rxSocketFactory = listener->GetObject<UdpSocketFactory> ();
   Ptr<Socket> rxSocket = rxSocketFactory->CreateSocket ();
   rxSocket->BindToNetDevice (listenerDev);
   NS_TEST_EXPECT_MSG_EQ (rxSocket->Bind (InetSocketAddress (Ipv4Address ("224.0.0.9"), 520)), 0, "trivial");
   rxSocket->SetRecvCallback (MakeCallback (&Ipv4RipSplitHorizonStrategyTest::ReceivePktProbe, this));

   // ------ Now the tests ------------

   // If the strategy is Split Horizon, then no packet will be received.
   m_detectedStrategy = Rip::SPLIT_HORIZON;

   Simulator::Stop (Seconds (66));
   Simulator::Run ();
   NS_TEST_EXPECT_MSG_EQ (m_detectedStrategy, m_setStrategy, "RIP counting to infinity.");

   Simulator::Destroy ();
 }


 class Ipv4RipTestSuite : public TestSuite
 {
 public:
   Ipv4RipTestSuite () : TestSuite ("ipv4-rip", UNIT)
   {
     AddTestCase (new Ipv4RipTest, TestCase::QUICK);
     AddTestCase (new Ipv4RipCountToInfinityTest, TestCase::QUICK);
     AddTestCase (new Ipv4RipSplitHorizonStrategyTest (Rip::POISON_REVERSE), TestCase::QUICK);
     AddTestCase (new Ipv4RipSplitHorizonStrategyTest (Rip::SPLIT_HORIZON), TestCase::QUICK);
     AddTestCase (new Ipv4RipSplitHorizonStrategyTest (Rip::NO_SPLIT_HORIZON), TestCase::QUICK);
   }
 };

 static Ipv4RipTestSuite g_ipv4ripTestSuite;
ns3::Packet::RemoveHeader
uint32_t RemoveHeader(Header &header)
Deserialize and remove the header from the internal buffer.
Definition: packet.cc:280

ns3::InetSocketAddress
an Inet address class
Definition: inet-socket-address.h:40

ns3::Ptr< Packet >

Ipv4RipTest::m_receivedPacket
Ptr< Packet > m_receivedPacket
Received packet.
Definition: ipv4-rip-test.cc:58

ns3::Node::GetId
uint32_t GetId(void) const
Definition: node.cc:107

g_ipv4ripTestSuite
static Ipv4RipTestSuite g_ipv4ripTestSuite
Static variable for test initialization.
Definition: ipv4-rip-test.cc:704

ns3::Ipv4InterfaceContainer
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Definition: ipv4-interface-container.h:54

ns3::Ipv4StaticRouting::SetDefaultRoute
void SetDefaultRoute(Ipv4Address nextHop, uint32_t interface, uint32_t metric=0)
Add a default route to the static routing table.
Definition: ipv4-static-routing.cc:112

ns3::Packet::GetSize
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:852

ns3::Socket::SetAllowBroadcast
virtual bool SetAllowBroadcast(bool allowBroadcast)=0
Configure whether broadcast datagram transmissions are allowed.

ns3::Ipv4Mask
a class to represent an Ipv4 address mask
Definition: ipv4-address.h:258

ns3::TestSuite
A suite of tests to run.
Definition: test.h:1342

Ipv4RipTestSuite
IPv4 RIP TestSuite.
Definition: ipv4-rip-test.cc:691

NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file...
Definition: assert.h:67

ns3::InternetStackHelper
aggregate IP/TCP/UDP functionality to existing Nodes.
Definition: internet-stack-helper.h:86

NS_TEST_EXPECT_MSG_EQ
#define NS_TEST_EXPECT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report if not.
Definition: test.h:285

ns3::SocketFactory::CreateSocket
virtual Ptr< Socket > CreateSocket(void)=0

ns3::RipHelper
Helper class that adds RIP routing to nodes.
Definition: rip-helper.h:40

ns3::TestCase
encapsulates test code
Definition: test.h:1155

Ipv4RipSplitHorizonStrategyTest::m_detectedStrategy
Rip::SplitHorizonType_e m_detectedStrategy
Strategy detected.
Definition: ipv4-rip-test.cc:508

Ipv4RipSplitHorizonStrategyTest::Ipv4RipSplitHorizonStrategyTest
Ipv4RipSplitHorizonStrategyTest(Rip::SplitHorizonType_e strategy)
Constructor.
Definition: ipv4-rip-test.cc:526

Ipv4RipCountToInfinityTest
IPv4 RIP count to infinity Test.
Definition: ipv4-rip-test.cc:278

ns3::Address
a polymophic address class
Definition: address.h:90

ns3::RipHelper::Set
void Set(std::string name, const AttributeValue &value)
Definition: rip-helper.cc:81

Ipv4RipCountToInfinityTest::ReceivePkt
void ReceivePkt(Ptr< Socket > socket)
Receive data.
Definition: ipv4-rip-test.cc:311

Ipv4RipTestSuite::Ipv4RipTestSuite
Ipv4RipTestSuite()
Definition: ipv4-rip-test.cc:694

first.nodes
nodes
Definition: first.py:25

ns3::EnumValue
Hold variables of type enum.
Definition: enum.h:54

max
#define max(a, b)
Definition: 80211b.c:43

ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299

ns3::NetDeviceContainer::Add
void Add(NetDeviceContainer other)
Append the contents of another NetDeviceContainer to the end of this container.
Definition: net-device-container.cc:67

Ipv4RipSplitHorizonStrategyTest::m_setStrategy
Rip::SplitHorizonType_e m_setStrategy
Strategy set.
Definition: ipv4-rip-test.cc:507

Ipv4RipTest::SendData
void SendData(Ptr< Socket > socket, std::string to)
Send data.
Definition: ipv4-rip-test.cc:109

Ipv4RipCountToInfinityTest::m_receivedPacket
Ptr< Packet > m_receivedPacket
Received packet.
Definition: ipv4-rip-test.cc:280

Ipv4RipSplitHorizonStrategyTest
IPv4 RIP SplitHorizon strategy Test.
Definition: ipv4-rip-test.cc:505

ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:41

Ipv4RipTest::ReceivePkt
void ReceivePkt(Ptr< Socket > socket)
Receive data.
Definition: ipv4-rip-test.cc:89

Ipv4RipSplitHorizonStrategyTest::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: ipv4-rip-test.cc:576

ns3::MakeCallback
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1489

ns3::Rip::SplitHorizonType_e
SplitHorizonType_e
Split Horizon strategy type.
Definition: rip.h:202

Ipv4RipCountToInfinityTest::SendData
void SendData(Ptr< Socket > socket, std::string to)
Send data.
Definition: ipv4-rip-test.cc:331

ns3::RipHeader
RipHeader - see RFC 2453
Definition: rip-header.h:157

ns3::Ipv4
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:76

ns3::Object::GetObject
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:459

ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.

ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:38

Ipv4RipTest::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: ipv4-rip-test.cc:119

Ipv4RipTest
IPv4 RIP Test.
Definition: ipv4-rip-test.cc:56

ns3::Socket::Recv
virtual Ptr< Packet > Recv(uint32_t maxSize, uint32_t flags)=0
Read data from the socket.

ns3::Mac48Address
an EUI-48 address
Definition: mac48-address.h:43

ns3::RipHelper::SetInterfaceMetric
void SetInterfaceMetric(Ptr< Node > node, uint32_t interface, uint8_t metric)
Set a metric for an interface.
Definition: rip-helper.cc:176

ns3::Socket::BindToNetDevice
virtual void BindToNetDevice(Ptr< NetDevice > netdevice)
Bind a socket to specific device.
Definition: socket.cc:330

ns3::InternetStackHelper::Install
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
Definition: internet-stack-helper.cc:366

Ipv4RipCountToInfinityTest::DoSendData
void DoSendData(Ptr< Socket > socket, std::string to)
Send data.
Definition: ipv4-rip-test.cc:323

ns3::Ipv4Address
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:40

ns3::Ipv4AddressHelper::Assign
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
Definition: ipv4-address-helper.cc:135

ns3::Node::AddDevice
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
Definition: node.cc:128

ns3::Socket::GetNode
virtual Ptr< Node > GetNode(void) const =0
Return the node this socket is associated with.

Ipv4RipCountToInfinityTest::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: ipv4-rip-test.cc:341

ns3::SimpleNetDevice::SetAddress
virtual void SetAddress(Address address)
Set the address of this interface.
Definition: simple-net-device.cc:323

ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1062

ns3::Packet::RemoveAllByteTags
void RemoveAllByteTags(void)
Remove all byte tags stored in this packet.
Definition: packet.cc:371

ns3::Socket::SendTo
virtual int SendTo(Ptr< Packet > p, uint32_t flags, const Address &toAddress)=0
Send data to a specified peer.

ns3::Ipv4AddressHelper
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Definition: ipv4-address-helper.h:47

ns3::UdpSocketFactory
API to create UDP socket instances.
Definition: udp-socket-factory.h:41

ns3::Socket::RecvFrom
virtual Ptr< Packet > RecvFrom(uint32_t maxSize, uint32_t flags, Address &fromAddress)=0
Read a single packet from the socket and retrieve the sender address.

ns3::TestSuite::UNIT
This test suite implements a Unit Test.
Definition: test.h:1352

ns3::SimpleNetDevice::SetChannel
void SetChannel(Ptr< SimpleChannel > channel)
Attach a channel to this net device.
Definition: simple-net-device.cc:274

ns3::RipHeader::GetRteList
std::list< RipRte > GetRteList(void) const
Get the list of the RTEs included in the message.
Definition: rip-header.cc:272

Ipv4RipTest::Ipv4RipTest
Ipv4RipTest()
Definition: ipv4-rip-test.cc:84

Ipv4RipSplitHorizonStrategyTest::ReceivePktProbe
void ReceivePktProbe(Ptr< Socket > socket)
Receive data.
Definition: ipv4-rip-test.cc:532

ns3::InternetStackHelper::SetRoutingHelper
void SetRoutingHelper(const Ipv4RoutingHelper &routing)
Definition: internet-stack-helper.cc:175

Ipv4RipCountToInfinityTest::Ipv4RipCountToInfinityTest
Ipv4RipCountToInfinityTest()
Definition: ipv4-rip-test.cc:306

ns3::Ipv4AddressHelper::SetBase
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
Definition: ipv4-address-helper.cc:64

Ipv4RipTest::DoSendData
void DoSendData(Ptr< Socket > socket, std::string to)
Send data.
Definition: ipv4-rip-test.cc:101

ns3::Socket::GetRxAvailable
virtual uint32_t GetRxAvailable(void) const =0
Return number of bytes which can be returned from one or multiple calls to Recv.