.AddTraceSource ("Tx", "A new packet is created and is sent",

                     MakeTraceSourceAccessor (&UdpClient::m_txTrace),

                     "ns3::Packet::TracedCallback")

  m_txTrace (p);

#include "ns3/traced-callback.h"

  /// Callbacks for tracing the packet Tx events

  TracedCallback<Ptr<const Packet> > m_txTrace;

#include "ns3/udp-client-server-helper.h"

#include "ns3/qos-tag.h"

#include "ns3/internet-stack-helper.h"

#include "ns3/ipv4-address-helper.h"

#include "ns3/ipv4-global-routing-helper.h"

#include "ns3/ipv4-interface.h"

#include "ns3/ipv4-l3-protocol.h"

#include "ns3/arp-cache.h"

#include "ns3/node-list.h"

#include "ns3/object-vector.h"

void

TagMarker(uint8_t tid, Ptr<const Packet> packet)

{

    QosTag qosTag;

    qosTag.SetTid(tid);

    packet->AddPacketTag(qosTag);

}

/**

 * Make sure that when virtual collision occurs the wifi remote station manager 

 * is triggered and the retry counter is increased.

 *

 * See \bugid{2222}

 */

class Bug2222TestCase : public TestCase

{

public:

  Bug2222TestCase ();

  virtual ~Bug2222TestCase ();

  virtual void DoRun (void);

private:

  uint32_t m_countInternalCollisions;

  void PopulateArpCache ();

  void TxDataFailedTrace (std::string context, Mac48Address adr);

};

Bug2222TestCase::Bug2222TestCase ()

  : TestCase ("Test case for Bug 2222"),

    m_countInternalCollisions (0)

{

}

Bug2222TestCase::~Bug2222TestCase ()

{

}

void Bug2222TestCase::PopulateArpCache()

{

    Ptr<ArpCache> arp = CreateObject<ArpCache> ();

    arp->SetAliveTimeout (Seconds (3600 * 24 * 365));

    for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)

    {

      Ptr<Ipv4L3Protocol> ip = (*i)->GetObject<Ipv4L3Protocol> ();

      ObjectVectorValue interfaces;

      ip->GetAttribute ("InterfaceList", interfaces);

      for (ObjectVectorValue::Iterator j = interfaces.Begin (); j != interfaces.End (); j++)

      {

        Ptr<Ipv4Interface> ipIface = StaticCast<Ipv4Interface, Object> ((*j).second);

        Ptr<NetDevice> device = ipIface->GetDevice ();

        Mac48Address addr = Mac48Address::ConvertFrom(device->GetAddress ());

        for (uint32_t k = 0; k < ipIface->GetNAddresses (); k++)

        {

          Ipv4Address ipAddr = ipIface->GetAddress (k).GetLocal ();

          if (ipAddr == Ipv4Address::GetLoopback ())

            continue;

          ArpCache::Entry * entry = arp->Add (ipAddr);

          entry->SetMacAddresss (addr);

          entry->MarkPermanent ();

        }

      }

    }

    for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)

    {

      Ptr<Ipv4L3Protocol> ip = (*i)->GetObject<Ipv4L3Protocol> ();

      ObjectVectorValue interfaces;

      ip->GetAttribute("InterfaceList", interfaces);

      for (ObjectVectorValue::Iterator j = interfaces.Begin (); j != interfaces.End (); j++)

      {

        Ptr<Ipv4Interface> ipIface = StaticCast<Ipv4Interface, Object> ((*j).second);

        ipIface->SetAttribute ("ArpCache", PointerValue (arp));

      }

    }

}

void

Bug2222TestCase::TxDataFailedTrace (std::string context, Mac48Address adr)

{

  //Indicate the long retry counter has been increased in the wifi remote station manager

  m_countInternalCollisions++;

}

void

Bug2222TestCase::DoRun (void)

{

  m_countInternalCollisions = 0;

  //Generate same backoff for AC_VI and AC_VO

  RngSeedManager::SetSeed (1);

  RngSeedManager::SetRun (9);

  NodeContainer wifiApNode;

  NodeContainer wifiStaNode;

  wifiApNode.Create (1);

  wifiStaNode.Create (1);

  YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();

  YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();

  phy.SetChannel (channel.Create ());

  phy.SetPcapDataLinkType (YansWifiPhyHelper::DLT_IEEE802_11_RADIO);

  WifiHelper wifi;

  WifiMacHelper mac;

  Ssid ssid = Ssid ("ns3-80211a");

  mac.SetType ("ns3::AdhocWifiMac",

               "Ssid", SsidValue(ssid),

               "QosSupported", BooleanValue (true));

  NetDeviceContainer apDevice = wifi.Install (phy, mac, wifiApNode);

  NetDeviceContainer staDevice = wifi.Install (phy, mac, wifiStaNode);

  Ptr<ListPositionAllocator> positionAllocator = CreateObject<ListPositionAllocator>();

  positionAllocator->Add (Vector (0.0, 0.0, 0.0));

  positionAllocator->Add (Vector (1.0, 0.0, 0.0));

  MobilityHelper mobility;

  mobility.SetPositionAllocator (positionAllocator);

  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");

  mobility.Install (wifiApNode);

  mobility.Install (wifiStaNode);

  InternetStackHelper stack;

  stack.Install (wifiApNode);

  stack.Install (wifiStaNode);

  Ipv4AddressHelper address;

  address.SetBase ("192.168.1.0", "255.255.255.0");

  Ipv4InterfaceContainer apNodeInterface = address.Assign (apDevice);

  address.Assign (staDevice);

  UdpClientHelper clientHelperVideo (apNodeInterface.GetAddress (0), 4000);

  clientHelperVideo.SetAttribute ("MaxPackets", UintegerValue (1u));

  clientHelperVideo.SetAttribute ("PacketSize", UintegerValue (1500));

  ApplicationContainer clientAppVideo = clientHelperVideo.Install (wifiStaNode);

  clientAppVideo.Start (Seconds (0.0));

  Ptr<UdpClient> udpClientVideo;

  udpClientVideo = DynamicCast<UdpClient> (clientAppVideo.Get (0));

  udpClientVideo->TraceConnectWithoutContext ("Tx",  MakeBoundCallback(&TagMarker, UP_VI));

  UdpClientHelper clientHelperVoice (apNodeInterface.GetAddress (0), 5000);

  clientHelperVoice.SetAttribute ("MaxPackets", UintegerValue (1u));

  clientHelperVoice.SetAttribute ("PacketSize", UintegerValue (1000));

  ApplicationContainer clientAppVoice = clientHelperVoice.Install(wifiStaNode);

  clientAppVoice.Start (Seconds (0.0));

  Ptr<UdpClient> udpClientVoice;

  udpClientVoice = DynamicCast<UdpClient> (clientAppVoice.Get (0));

  udpClientVoice->TraceConnectWithoutContext ("Tx",  MakeBoundCallback(&TagMarker, UP_VO));

  Bug2222TestCase::PopulateArpCache ();

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

  Config::Connect ("/NodeList/*/DeviceList/*/RemoteStationManager/MacTxDataFailed", MakeCallback (&Bug2222TestCase::TxDataFailedTrace, this));

  Simulator::Stop (Seconds (1.0));

  Simulator::Run ();

  Simulator::Destroy ();

  NS_TEST_ASSERT_MSG_EQ (m_countInternalCollisions, 1, "unexpected number of internal collisions!");

}

//-----------------------------------------------------------------------------

  AddTestCase (new Bug2222TestCase, TestCase::QUICK); //Bug 2222