/**

 * Make sure that when two broadcast packets are queued on the same

 * device in a short succession no virtual collision occurs 

 * 

 */

class Bug555Test : public TestCase

{

public:

  Bug555Test ();

  virtual bool DoRun (void);

  void Receive (Ptr<Packet>, double x, WifiMode mode, enum WifiPreamble preamble);

private:

  void RunOne (void);

  void CreateOne (Vector pos, Ptr<YansWifiChannel> channel);

  void SendOnePacket (Ptr<WifiNetDevice> dev);

  ObjectFactory m_manager;

  ObjectFactory m_mac; 

  ObjectFactory m_propDelay;

  unsigned int m_numReceivedPackets;

};

Bug555Test::Bug555Test ()

  : TestCase ("Bug555")

{

}

void

Bug555Test::SendOnePacket (Ptr<WifiNetDevice> dev)

{

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

  dev->Send (p, dev->GetBroadcast (), 1);

}

bool

Bug555Test::DoRun (void)

{

  m_mac.SetTypeId ("ns3::AdhocWifiMac");

  m_propDelay.SetTypeId ("ns3::ConstantSpeedPropagationDelayModel");

  m_manager.SetTypeId ("ns3::ConstantRateWifiManager");

  Ptr<YansWifiChannel> channel = CreateObject<YansWifiChannel> ();

  Ptr<PropagationDelayModel> propDelay = m_propDelay.Create<PropagationDelayModel> ();

  Ptr<PropagationLossModel> propLoss = CreateObject<RandomPropagationLossModel> ();

  channel->SetPropagationDelayModel (propDelay);

  channel->SetPropagationLossModel (propLoss);

  Ptr<Node> txNode = CreateObject<Node> ();

  Ptr<WifiNetDevice> txDev = CreateObject<WifiNetDevice> ();

  Ptr<WifiMac> txMac = m_mac.Create<WifiMac> ();

  txMac->ConfigureStandard (WIFI_PHY_STANDARD_80211a);

  Ptr<ConstantPositionMobilityModel> txMobility = CreateObject<ConstantPositionMobilityModel> ();

  Ptr<YansWifiPhy> txPhy = CreateObject<YansWifiPhy> ();

  Ptr<ErrorRateModel> txError = CreateObject<YansErrorRateModel> ();

  txPhy->SetErrorRateModel (txError);

  txPhy->SetChannel (channel);

  txPhy->SetDevice (txDev);

  txPhy->SetMobility (txNode);

  txPhy->ConfigureStandard (WIFI_PHY_STANDARD_80211a);

  txMobility->SetPosition (Vector (0.0, 0.0, 0.0));

  txNode->AggregateObject (txMobility);

  txMac->SetAddress (Mac48Address::Allocate ());

  txDev->SetMac (txMac);

  txDev->SetPhy (txPhy);

  txDev->SetRemoteStationManager (m_manager.Create<WifiRemoteStationManager> ());

  txNode->AddDevice (txDev);

  Ptr<Node> rxNode = CreateObject<Node> ();

  Ptr<WifiNetDevice> rxDev = CreateObject<WifiNetDevice> ();

  Ptr<WifiMac> rxMac = m_mac.Create<WifiMac> ();

  rxMac->ConfigureStandard (WIFI_PHY_STANDARD_80211a);

  Ptr<ConstantPositionMobilityModel> rxMobility = CreateObject<ConstantPositionMobilityModel> ();

  Ptr<YansWifiPhy> rxPhy = CreateObject<YansWifiPhy> ();

  Ptr<ErrorRateModel> rxError = CreateObject<YansErrorRateModel> ();

  rxPhy->SetErrorRateModel (rxError);

  rxPhy->SetChannel (channel);

  rxPhy->SetDevice (rxDev);

  rxPhy->SetMobility (rxNode);

  rxPhy->ConfigureStandard (WIFI_PHY_STANDARD_80211a);

  Ptr<WifiRemoteStationManager> manager = m_manager.Create<WifiRemoteStationManager> ();

  rxMobility->SetPosition (Vector (0.0, 0.0, 0.0));

  rxNode->AggregateObject (rxMobility);

  rxMac->SetAddress (Mac48Address::Allocate ());

  rxDev->SetMac (rxMac);

  rxDev->SetPhy (rxPhy);

  rxDev->SetRemoteStationManager (m_manager.Create<WifiRemoteStationManager> ());

  rxNode->AddDevice (rxDev);

  rxPhy->SetReceiveOkCallback (MakeCallback (&Bug555Test::Receive, this));

  m_numReceivedPackets = 0;

  Simulator::Schedule (Seconds (1.000000), &Bug555Test::SendOnePacket, this, txDev);

  Simulator::Schedule (Seconds (1.000040), &Bug555Test::SendOnePacket, this, txDev);

  Simulator::Stop (Seconds (10.0));

  Simulator::Run ();

  Simulator::Destroy ();

  return (m_numReceivedPackets != 2);

}

void 

Bug555Test:: Receive (Ptr<Packet>, double x, WifiMode mode, enum WifiPreamble preamble)

{

  ++m_numReceivedPackets;

}

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

  AddTestCase (new Bug555Test);