#ifdef RUN_SELF_TESTS

#include "wifi-net-device.h"

#include "wifi-channel.h"

#include "adhoc-wifi-mac.h"

#include "arf-wifi-manager.h"

#include "propagation-delay-model.h"

#include "propagation-loss-model.h"

#include "ns3/static-mobility-model.h"

#include "ns3/node.h"

#include "ns3/simulator.h"

#include "ns3/test.h"

#include "ns3/object-factory.h"

namespace ns3 {

class WifiTest : public Test

{

public:

  WifiTest ();

  virtual bool RunTests (void);

private:

  void RunOne (void);

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

  void SendOnePacket (Ptr<WifiNetDevice> dev);

  ObjectFactory m_manager;

  ObjectFactory m_mac;

  ObjectFactory m_propDelay;

};

WifiTest::WifiTest ()

  : Test ("Wifi")

{}

void 

WifiTest::SendOnePacket (Ptr<WifiNetDevice> dev)

{

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

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

}

void 

WifiTest::CreateOne (Vector pos, Ptr<WifiChannel> channel)

{

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

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

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

  Ptr<StaticMobilityModel> mobility = CreateObject<StaticMobilityModel> ();

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

  mobility->SetPosition (pos);

  node->AggregateObject (mobility);

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

  dev->SetMac (mac);

  dev->SetPhy (phy);

  dev->SetRemoteStationManager (manager);

  dev->SetChannel (channel);

  node->AddDevice (dev);

  Simulator::Schedule (Seconds (1.0), &WifiTest::SendOnePacket, this, dev);

}

void

WifiTest::RunOne (void)

{

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

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

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

  channel->SetPropagationDelayModel (propDelay);

  channel->SetPropagationLossModel (propLoss);

  CreateOne (Vector (0.0, 0.0, 0.0), channel);

  CreateOne (Vector (5.0, 0.0, 0.0), channel);

  CreateOne (Vector (5.0, 0.0, 0.0), channel);

  Simulator::Run ();

  Simulator::Destroy ();

  Simulator::Stop (Seconds (10.0));

}

bool

WifiTest::RunTests (void)

{

  bool result = true;

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

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

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

  RunOne ();

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

  RunOne ();

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

  RunOne ();

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

  RunOne ();

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

  RunOne ();

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

  RunOne ();

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

  RunOne ();

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

  RunOne ();

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

  RunOne ();

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

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

  RunOne ();

  return result;

}

static WifiTest g_wifiTest;

} // namespace ns3

#endif /* RUN_SELF_TESTS */