#include "ns3/simple-net-device-helper.h"

#include "ns3/simple-net-device.h"

#include "ns3/icmpv4.h"

  m_time (Seconds (200.0))

  m_time (Seconds (200.0)), m_seq (0), m_recvCount (0)

  int nWifis = 3;

  NodeContainer c;

  double SimTime = 200.0;

  c.Create (3);

  std::string phyMode ("DsssRate1Mbps");

  int64_t streamsUsed = 0;

  //sending one packets per sec

  // install TCP/IP & OLSR

  // Fix non-unicast data rate to be the same as that of unicast

  Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold",

                      StringValue ("400"));

  NodeContainer adhocNodes;

  adhocNodes.Create (nWifis);

  WifiHelper wifi;

  YansWifiPhyHelper wifiPhy =  YansWifiPhyHelper::Default ();

  YansWifiChannelHelper wifiChannel;

  wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");

  wifiChannel.AddPropagationLoss ("ns3::FriisPropagationLossModel");

  Ptr<YansWifiChannel> chan = wifiChannel.Create ();

  wifiPhy.SetChannel (chan);

  // Add a non-QoS upper mac, and disable rate control

  NqosWifiMacHelper wifiMac = NqosWifiMacHelper::Default ();

  wifi.SetStandard (WIFI_PHY_STANDARD_80211b);

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",

                                "DataMode",StringValue (phyMode),

                                "ControlMode",StringValue (phyMode));

  //set the tx range to 300

  wifiPhy.Set ("TxPowerStart",DoubleValue (-0.1615));

  wifiPhy.Set ("TxPowerEnd", DoubleValue (-0.1615));

  // Set it to adhoc mode

  wifiMac.SetType ("ns3::AdhocWifiMac");

  NetDeviceContainer adhocDevices = wifi.Install (wifiPhy, wifiMac, adhocNodes);

  // Assign fixed stream numbers to wifi and channel random variables

  streamsUsed += wifi.AssignStreams (adhocDevices, streamsUsed);

  // Assign 6 streams per Wifi device

  NS_TEST_ASSERT_MSG_EQ (streamsUsed, (adhocDevices.GetN () * 6), "Stream assignment mismatch");

  streamsUsed += wifiChannel.AssignStreams (chan, streamsUsed);

  // Assign 0 additional streams per channel for this configuration 

  NS_TEST_ASSERT_MSG_EQ (streamsUsed, (adhocDevices.GetN () * 6), "Stream assignment mismatch");

  internet.Install (adhocNodes);

  internet.Install (c);

  // Assign 3 streams per node to internet stack for this configuration

  int64_t streamsUsed = olsr.AssignStreams (c, 0);

  streamsUsed += internet.AssignStreams (adhocNodes, streamsUsed);

  NS_TEST_EXPECT_MSG_EQ (streamsUsed, 3, "Should have assigned 3 streams");

  NS_TEST_ASSERT_MSG_EQ (streamsUsed, (adhocDevices.GetN () * 6) + (adhocNodes.GetN () * 3), "Stream assignment mismatch");

  // Olsr uses one additional stream per wifi device for this configuration

  // create channel & devices

  streamsUsed += olsr.AssignStreams (adhocNodes, 0);

  SimpleNetDeviceHelper simpleNetHelper;

  NS_TEST_ASSERT_MSG_EQ (streamsUsed, ((adhocDevices.GetN () * 6) + (adhocDevices.GetN () * 3) + nWifis), "Should have assigned 3 streams");

  simpleNetHelper.SetDeviceAttribute ("DataRate", StringValue ("10Mbps"));

  simpleNetHelper.SetChannelAttribute ("Delay", StringValue ("2ms"));

  NetDeviceContainer nd = simpleNetHelper.Install (c);

  adhocInterfaces = addressAdhoc.Assign (adhocDevices);

  adhocInterfaces = addressAdhoc.Assign (nd);

  MobilityHelper mobilityAdhoc;

  // Blacklist some devices (equivalent to Wireless out of range)

  Ptr<SimpleNetDevice> nd0 = DynamicCast<SimpleNetDevice> (nd.Get (0));

  Ptr<SimpleNetDevice> nd2 = DynamicCast<SimpleNetDevice> (nd.Get (2));

  Ptr<SimpleChannel> ch = DynamicCast<SimpleChannel> (nd.Get (0)->GetChannel ());

  Ptr<ListPositionAllocator> positionAlloc_Adhoc =

  Simulator::Schedule (Seconds (100.0), &SimpleChannel::BlackList, ch, nd0, nd2);

    CreateObject<ListPositionAllocator>();

  Simulator::Schedule (Seconds (100.0), &SimpleChannel::BlackList, ch, nd2, nd0);

  double distance = 0.0;

  for (uint32_t i = 0; i <= adhocNodes.GetN (); i++)

    {

      positionAlloc_Adhoc->Add (Vector (distance,0.0,0.0));

      distance += 250.0;

    }

  mobilityAdhoc.SetMobilityModel ("ns3::ConstantVelocityMobilityModel");

  // 3. Setup ping

  mobilityAdhoc.SetPositionAllocator (positionAlloc_Adhoc);

  m_socket = Socket::CreateSocket (c.Get (0), TypeId::LookupByName ("ns3::Ipv4RawSocketFactory"));

  mobilityAdhoc.Install (adhocNodes);

  m_socket->SetAttribute ("Protocol", UintegerValue (1)); // icmp

  m_socket->SetRecvCallback (MakeCallback (&Bug780Test::Receive, this));

  InetSocketAddress src = InetSocketAddress (Ipv4Address::GetAny (), 0);

  m_socket->Bind (src);

  InetSocketAddress dst = InetSocketAddress (adhocInterfaces.GetAddress (2), 0);

  m_socket->Connect (dst);

  //At 50 sec node 3 moves towards node 2

  SendPing ();

  Simulator::Schedule (Seconds (50.0), &SetVelocity, adhocNodes.Get (2),Vector (-5.0,0.0,0.0));

  //AT 100 sec set node 3 with zero velocity

  Simulator::Schedule (Seconds (100.0), &SetVelocity, adhocNodes.Get (2),Vector (0.0,0.0,0.0));

  //Move node2 away from node 3

  Simulator::Schedule (Seconds (100.0), &SetVelocity, adhocNodes.Get (1),Vector (5.0,0.0,0.0));

  //AT 150 sec set node 2 with zero velocity

  Simulator::Schedule (Seconds (150.0), &SetVelocity, adhocNodes.Get (1), Vector (0.0,0.0,0.0));

  // Ping 10.1.1.1 -> 10.1.1.2

  V4PingHelper ping (adhocInterfaces.GetAddress (1));

  ping.SetAttribute ("Verbose", BooleanValue (true));

  ApplicationContainer p = ping.Install (adhocNodes.Get (0));

  p.Start (Seconds (50));

  p.Stop (Seconds (SimTime) - Seconds (0.001));

  // pcap

  wifiPhy.EnablePcapAll (CreateTempDirFilename (PREFIX));

Bug780Test::CheckResults ()

Bug780Test::SendPing ()

  for (uint32_t i = 0; i < 2; ++i)

  if (Simulator::Now () >= m_time)

      NS_PCAP_TEST_EXPECT_EQ (PREFIX << "-" << i << "-0.pcap");

      return;

    }

  Ptr<Packet> p = Create<Packet> ();

  Icmpv4Echo echo;

  echo.SetSequenceNumber (m_seq);

  m_seq++;

  echo.SetIdentifier (0);

  Ptr<Packet> dataPacket = Create<Packet> (56);

  echo.SetData (dataPacket);

  p->AddHeader (echo);

  Icmpv4Header header;

  header.SetType (Icmpv4Header::ECHO);

  header.SetCode (0);

  if (Node::ChecksumEnabled ())

    {

      header.EnableChecksum ();

    }

  p->AddHeader (header);

  m_socket->Send (p, 0);

  Simulator::Schedule (Seconds (1), &Bug780Test::SendPing, this);

}

void

Bug780Test::Receive (Ptr<Socket> socket)

{

  while (m_socket->GetRxAvailable () > 0)

    {

      Address from;

      Ptr<Packet> p = m_socket->RecvFrom (0xffffffff, 0, from);

      NS_ASSERT (InetSocketAddress::IsMatchingType (from));

      InetSocketAddress realFrom = InetSocketAddress::ConvertFrom (from);

      NS_ASSERT (realFrom.GetPort () == 1); // protocol should be icmp.

      Ipv4Header ipv4;

      p->RemoveHeader (ipv4);

      NS_ASSERT (ipv4.GetProtocol () == 1); // protocol should be icmp.

      Icmpv4Header icmp;

      p->RemoveHeader (icmp);

      if (icmp.GetType () == Icmpv4Header::ECHO_REPLY)

        {

          m_recvCount ++;

        }

#include "ns3/point-to-point-helper.h"

#include "ns3/simple-net-device-helper.h"

#include "ns3/pcap-test.h"

#include "ns3/socket-factory.h"

#include "ns3/ipv4-raw-socket-factory.h"

#include "ns3/udp-l4-protocol.h"

#include "ns3/udp-header.h"

#include "ns3/olsr-header.h"

  m_time (Seconds (5))

  m_time (Seconds (5)), m_countA (0), m_countB (0)

  // create p2p channel & devices

  // create channel & devices

  PointToPointHelper p2p;

  SimpleNetDeviceHelper simpleNetHelper;

  p2p.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));

  simpleNetHelper.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));

  p2p.SetChannelAttribute ("Delay", StringValue ("2ms"));

  simpleNetHelper.SetChannelAttribute ("Delay", StringValue ("2ms"));

  NetDeviceContainer nd = p2p.Install (c);

  NetDeviceContainer nd = simpleNetHelper.Install (c);

  // setup PCAP traces

  p2p.EnablePcapAll (CreateTempDirFilename (PREFIX));

  // Create the sockets

  Ptr<SocketFactory> rxSocketFactoryA = c.Get (0)->GetObject<Ipv4RawSocketFactory> ();

  m_rxSocketA = DynamicCast<Ipv4RawSocketImpl> (rxSocketFactoryA->CreateSocket ());

  m_rxSocketA->SetProtocol (UdpL4Protocol::PROT_NUMBER);

  m_rxSocketA->SetRecvCallback (MakeCallback (&HelloRegressionTest::ReceivePktProbeA, this));

  Ptr<SocketFactory> rxSocketFactoryB = c.Get (1)->GetObject<Ipv4RawSocketFactory> ();

  m_rxSocketB = DynamicCast<Ipv4RawSocketImpl> (rxSocketFactoryB->CreateSocket ());

  m_rxSocketB->SetProtocol (UdpL4Protocol::PROT_NUMBER);

  m_rxSocketB->SetRecvCallback (MakeCallback (&HelloRegressionTest::ReceivePktProbeB, this));

HelloRegressionTest::CheckResults ()

HelloRegressionTest::ReceivePktProbeA (Ptr<Socket> socket)

  for (uint32_t i = 0; i < 2; ++i)

  uint32_t availableData;

  availableData = socket->GetRxAvailable ();

  Ptr<Packet> receivedPacketProbe = socket->Recv (std::numeric_limits<uint32_t>::max (), 0);

  NS_ASSERT (availableData == receivedPacketProbe->GetSize ());

  Ipv4Header ipHdr;

  receivedPacketProbe->RemoveHeader (ipHdr);

  UdpHeader udpHdr;

  receivedPacketProbe->RemoveHeader (udpHdr);

  PacketHeader pktHdr;

  receivedPacketProbe->RemoveHeader (pktHdr);

  MessageHeader msgHdr;

  receivedPacketProbe->RemoveHeader (msgHdr);

  const olsr::MessageHeader::Hello &hello = msgHdr.GetHello ();

  NS_TEST_EXPECT_MSG_EQ (msgHdr.GetOriginatorAddress (), Ipv4Address ("10.1.1.2"), "Originator address.");

  if (m_countA == 0)

      NS_PCAP_TEST_EXPECT_EQ (PREFIX << "-" << i << "-1.pcap");

      NS_TEST_EXPECT_MSG_EQ (hello.linkMessages.size (), 0, "No Link messages on the first Hello.");

#include "ns3/yans-wifi-helper.h"

#include "ns3/socket-factory.h"

#include "ns3/mobility-helper.h"

#include "ns3/ipv4-raw-socket-factory.h"

#include "ns3/nqos-wifi-mac-helper.h"

#include "ns3/udp-l4-protocol.h"

#include "ns3/udp-header.h"

#include "ns3/olsr-header.h"

#include "ns3/simple-net-device-helper.h"

#include "ns3/simple-net-device.h"

  m_step (120)

  m_countA (0), m_countB (0), m_countC (0)

  NS_TEST_EXPECT_MSG_EQ (streamsUsed, 3, "Should have assigned 2 streams");

  NS_TEST_EXPECT_MSG_EQ (streamsUsed, 3, "Should have assigned 3 streams");

  // create wifi channel & devices

  // create channel & devices

  NqosWifiMacHelper wifiMac = NqosWifiMacHelper::Default ();

  SimpleNetDeviceHelper simpleNetHelper;

  wifiMac.SetType ("ns3::AdhocWifiMac");

  simpleNetHelper.SetDeviceAttribute ("DataRate", StringValue ("10Mbps"));

  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();

  simpleNetHelper.SetChannelAttribute ("Delay", StringValue ("2ms"));

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

  NetDeviceContainer nd = simpleNetHelper.Install (c);

  wifiPhy.SetChannel (wifiChannel.Create ());

  // This test suite output was originally based on YansErrorRateModel 

  // Blacklist some devices (equivalent to Wireless out of range)

  wifiPhy.SetErrorRateModel ("ns3::YansErrorRateModel");

  Ptr<SimpleNetDevice> nd0 = DynamicCast<SimpleNetDevice> (nd.Get (0));

  WifiHelper wifi = WifiHelper::Default ();

  Ptr<SimpleNetDevice> nd2 = DynamicCast<SimpleNetDevice> (nd.Get (2));

  wifi.SetStandard (WIFI_PHY_STANDARD_80211a);

  Ptr<SimpleChannel> ch = DynamicCast<SimpleChannel> (nd.Get (0)->GetChannel ());

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue ("OfdmRate6Mbps"), "RtsCtsThreshold", StringValue ("2200"));

  ch->BlackList (nd0, nd2);

  NetDeviceContainer nd = wifi.Install (wifiPhy, wifiMac, c); 

  ch->BlackList (nd2, nd0);

  // setup PCAP traces

  // Create the sockets

  wifiPhy.EnablePcapAll (CreateTempDirFilename(PREFIX));

  Ptr<SocketFactory> rxSocketFactoryA = c.Get (0)->GetObject<Ipv4RawSocketFactory> ();

  m_rxSocketA = DynamicCast<Ipv4RawSocketImpl> (rxSocketFactoryA->CreateSocket ());

  m_rxSocketA->SetProtocol (UdpL4Protocol::PROT_NUMBER);

  m_rxSocketA->SetRecvCallback (MakeCallback (&TcRegressionTest::ReceivePktProbeA, this));

  Ptr<SocketFactory> rxSocketFactoryB = c.Get (1)->GetObject<Ipv4RawSocketFactory> ();

  m_rxSocketB = DynamicCast<Ipv4RawSocketImpl> (rxSocketFactoryB->CreateSocket ());

  m_rxSocketB->SetProtocol (UdpL4Protocol::PROT_NUMBER);

  m_rxSocketB->SetRecvCallback (MakeCallback (&TcRegressionTest::ReceivePktProbeB, this));

  Ptr<SocketFactory> rxSocketFactoryC = c.Get (2)->GetObject<Ipv4RawSocketFactory> ();

  m_rxSocketC = DynamicCast<Ipv4RawSocketImpl> (rxSocketFactoryC->CreateSocket ());

  m_rxSocketC->SetProtocol (UdpL4Protocol::PROT_NUMBER);

  m_rxSocketC->SetRecvCallback (MakeCallback (&TcRegressionTest::ReceivePktProbeC, this));

}

// Note: this is identical to ReceivePktProbeC, but the packet counter needs to be different.

void

TcRegressionTest::ReceivePktProbeA (Ptr<Socket> socket)

{

  uint32_t availableData;

  availableData = socket->GetRxAvailable ();

  Ptr<Packet> receivedPacketProbe = socket->Recv (std::numeric_limits<uint32_t>::max (), 0);

  NS_ASSERT (availableData == receivedPacketProbe->GetSize ());

  Ipv4Header ipHdr;

  receivedPacketProbe->RemoveHeader (ipHdr);

  UdpHeader udpHdr;

  receivedPacketProbe->RemoveHeader (udpHdr);

  PacketHeader pktHdr;

  receivedPacketProbe->RemoveHeader (pktHdr);

  if (m_countA == 0)

    {

      MessageHeader msgHdr;

      receivedPacketProbe->RemoveHeader (msgHdr);

      const olsr::MessageHeader::Hello &hello = msgHdr.GetHello ();

      NS_TEST_EXPECT_MSG_EQ (msgHdr.GetOriginatorAddress (), Ipv4Address ("10.1.1.2"), "Originator address.");

      NS_TEST_EXPECT_MSG_EQ (hello.linkMessages.size (), 0, "0 - Hello, No messages.");

    }

  else if (m_countA == 1)

    {

      MessageHeader msgHdr;

      receivedPacketProbe->RemoveHeader (msgHdr);

      NS_TEST_EXPECT_MSG_EQ (msgHdr.GetOriginatorAddress (), Ipv4Address ("10.1.1.2"), "Originator address.");

      const olsr::MessageHeader::Hello &hello = msgHdr.GetHello ();

      NS_TEST_EXPECT_MSG_EQ (hello.linkMessages.size (), 2, "1 - Hello, one message.");

      NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[0].linkCode, 1, "1 - Asymmetric Link.");

      NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[0].neighborInterfaceAddresses.size (), 1, "1 - Neighbor.");

      NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[0].neighborInterfaceAddresses[0], Ipv4Address ("10.1.1.3"), "1 - Neighbor.");

      NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[1].linkCode, 1, "1 - Asymmetric Link.");

      NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[1].neighborInterfaceAddresses.size (), 1, "1 - Neighbor.");

      NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[1].neighborInterfaceAddresses[0], Ipv4Address ("10.1.1.1"), "1 - Neighbor.");

    }

  else

    {

      if (m_countA == 5 || m_countA == 8)

        {

          MessageHeader msgHdr;

          receivedPacketProbe->RemoveHeader (msgHdr);

          const olsr::MessageHeader::Tc &tc = msgHdr.GetTc ();

          NS_TEST_EXPECT_MSG_EQ (msgHdr.GetOriginatorAddress (), Ipv4Address ("10.1.1.2"), "Originator address.");

          NS_TEST_EXPECT_MSG_EQ (tc.neighborAddresses.size (), 2, int(m_countA) << " - TC, one message.");

          NS_TEST_EXPECT_MSG_EQ (tc.neighborAddresses[0], Ipv4Address ("10.1.1.3"), int(m_countA) << " - Neighbor.");

          NS_TEST_EXPECT_MSG_EQ (tc.neighborAddresses[1], Ipv4Address ("10.1.1.1"), int(m_countA) << " - Neighbor.");

        }

      if (m_countA != 8)

        {

          MessageHeader msgHdr;

          receivedPacketProbe->RemoveHeader (msgHdr);

          NS_TEST_EXPECT_MSG_EQ (msgHdr.GetOriginatorAddress (), Ipv4Address ("10.1.1.2"), "Originator address.");

          const olsr::MessageHeader::Hello &hello = msgHdr.GetHello ();

          NS_TEST_EXPECT_MSG_EQ (hello.linkMessages.size (), 2, int(m_countA) << " - Hello, one message.");

          NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[0].linkCode, 6, int(m_countA) << " - Symmetric Link.");

          NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[0].neighborInterfaceAddresses.size (), 1, int(m_countA) << " - Neighbor.");

          NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[0].neighborInterfaceAddresses[0], Ipv4Address ("10.1.1.3"), int(m_countA) << " - Neighbor.");

          NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[1].linkCode, 6, int(m_countA) << " - Symmetric Link.");

          NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[1].neighborInterfaceAddresses.size (), 1, int(m_countA) << " - Neighbor.");

          NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[1].neighborInterfaceAddresses[0], Ipv4Address ("10.1.1.1"), int(m_countA) << " - Neighbor.");

        }

    }

  m_countA ++;

TcRegressionTest::CheckResults ()

TcRegressionTest::ReceivePktProbeB (Ptr<Socket> socket)

  for (uint32_t i = 0; i < 3; ++i)

  uint32_t availableData;

  availableData = socket->GetRxAvailable ();

  Ptr<Packet> receivedPacketProbe = socket->Recv (std::numeric_limits<uint32_t>::max (), 0);

  NS_ASSERT (availableData == receivedPacketProbe->GetSize ());

  Ipv4Header ipHdr;

  receivedPacketProbe->RemoveHeader (ipHdr);

  UdpHeader udpHdr;

  receivedPacketProbe->RemoveHeader (udpHdr);

  PacketHeader pktHdr;

  receivedPacketProbe->RemoveHeader (pktHdr);

  MessageHeader msgHdr;

  receivedPacketProbe->RemoveHeader (msgHdr);

  const olsr::MessageHeader::Hello &hello = msgHdr.GetHello ();

  if (m_countB == 0 || m_countB == 2 || m_countB == 5 || m_countB == 6 || m_countB == 8 ||

      m_countB == 10 || m_countB == 13 || m_countB == 15 || m_countB == 17 || m_countB == 19)

      NS_PCAP_TEST_EXPECT_EQ (PREFIX << "-" << i << "-1.pcap");

      NS_TEST_EXPECT_MSG_EQ (msgHdr.GetOriginatorAddress (), Ipv4Address ("10.1.1.3"), "Originator address.");

 * This test creates 3 WiFi stations with chain topology and runs OLSR without any extra traffic. 

 * This test simulates 3 Wi-Fi stations with chain topology and runs OLSR without any extra traffic.

    module = bld.create_ns3_module('olsr', ['internet', 'config-store', 'point-to-point', 'wifi', 'applications'])

    module = bld.create_ns3_module('olsr', ['internet'])