wifi-aggregation-test.cc

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2015
 *
 * 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: Sébastien Deronne <sebastien.deronne@gmail.com>
 */

#include "ns3/string.h"
#include "ns3/test.h"
#include "ns3/object-factory.h"
#include "ns3/simulator.h"
#include "ns3/wifi-mac-queue.h"
#include "ns3/mac-low.h"
#include "ns3/edca-txop-n.h"
#include "ns3/yans-wifi-phy.h"

using namespace ns3;

class TwoLevelAggregationTest : public TestCase
{
public:
  TwoLevelAggregationTest ();

private:
  virtual void DoRun (void);
  Ptr<MacLow> m_low;
  Ptr<YansWifiPhy> m_phy;
  Ptr<EdcaTxopN> m_edca;
  Ptr<WifiRemoteStationManager> m_manager;
  ObjectFactory m_factory;
  Ptr<MpduAggregator> m_mpduAggregator;
  Ptr<MsduAggregator> m_msduAggregator;
};

TwoLevelAggregationTest::TwoLevelAggregationTest ()
  : TestCase ("Check the correctness of two-level aggregation operations")
{
}

void
TwoLevelAggregationTest::DoRun (void)
{
  /*
   * Create and configure phy layer.
   */
  m_phy = CreateObject<YansWifiPhy> ();
  m_phy->ConfigureStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

  /*
   * Create and configure manager.
   */
  m_factory = ObjectFactory ();
  m_factory.SetTypeId ("ns3::ConstantRateWifiManager");
  m_factory.Set ("DataMode", StringValue ("HtMcs7"));
  m_manager = m_factory.Create<WifiRemoteStationManager> ();
  m_manager->SetupPhy (m_phy);

  /*
   * Create and configure maclayer.
   */
  m_low = CreateObject<MacLow> ();
  m_low->SetPhy (m_phy);
  m_low->SetWifiRemoteStationManager (m_manager);

  m_edca = CreateObject<EdcaTxopN> ();
  m_edca->SetLow (m_low);
  m_edca->SetAccessCategory (AC_BE);
  m_edca->SetWifiRemoteStationManager (m_manager);
  m_edca->CompleteConfig ();

  /*
   * Configure aggregation.
   */
  m_factory = ObjectFactory ();
  m_factory.SetTypeId ("ns3::MsduStandardAggregator");
  m_factory.Set ("MaxAmsduSize", UintegerValue (4095));
  m_msduAggregator = m_factory.Create<MsduAggregator> ();
  m_edca->SetMsduAggregator (m_msduAggregator);

  m_factory = ObjectFactory ();
  m_factory.SetTypeId ("ns3::MpduStandardAggregator");
  m_factory.Set ("MaxAmpduSize", UintegerValue (65535));
  m_mpduAggregator = m_factory.Create<MpduAggregator> ();
  m_low->SetMpduAggregator (m_mpduAggregator);

  /*
   * Create dummy packets of 1500 bytes and fill mac header fields that will be used for the tests.
   */
  Ptr<const Packet> pkt = Create<Packet> (1500);
  Ptr<Packet> currentAggregatedPacket = Create<Packet> ();
  WifiMacHeader hdr, peekedHdr;
  hdr.SetAddr1 (Mac48Address ("00:00:00:00:00:01"));
  hdr.SetAddr2 (Mac48Address ("00:00:00:00:00:02"));
  hdr.SetType (WIFI_MAC_QOSDATA);
  hdr.SetQosTid (0);
  Time tstamp;

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

  /*
   * Test MSDU aggregation of two packets using MacLow::PerformMsduAggregation.
   * It checks whether aggregation succeeded:
   *      - returned packet should be different from 0;
   *      - A-MSDU frame size should be 3030 bytes (= 2 packets + headers + padding);
   *      - one packet should be removed from the queue (the other packet is removed later in MacLow::AggregateToAmpdu) .
   */
  m_edca->GetEdcaQueue ()->Enqueue (pkt, hdr);
  m_edca->GetEdcaQueue ()->Enqueue (pkt, hdr);

  Ptr<const Packet> peekedPacket = m_edca->GetEdcaQueue ()->PeekByTidAndAddress (&peekedHdr, 0,
                                                                                 WifiMacHeader::ADDR1,
                                                                                 hdr.GetAddr1 (),
                                                                                 &tstamp);
  m_low->m_currentPacket = peekedPacket->Copy ();
  m_low->m_currentHdr = peekedHdr;

  Ptr<Packet> packet = m_low->PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, 0);

  bool result = (packet != 0);
  NS_TEST_EXPECT_MSG_EQ (result, true, "aggregation failed");
  NS_TEST_EXPECT_MSG_EQ (packet->GetSize (), 3030, "wrong packet size");
  NS_TEST_EXPECT_MSG_EQ (m_edca->GetEdcaQueue ()->GetSize (), 0, "aggregated packets not removed from the queue");

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

  /*
   * Aggregation is refused when the maximum size is reached.
   * It checks whether MSDU aggregation has been rejected because the maximum MPDU size is set to 0 (returned packet should be equal to 0).
   * This test is needed to ensure that no packets are removed from the queue in MacLow::PerformMsduAggregation, since aggregation will no occur in MacLow::AggregateToAmpdu.
   */
  m_factory = ObjectFactory ();
  m_factory.SetTypeId ("ns3::MpduStandardAggregator");
  m_factory.Set ("MaxAmpduSize", UintegerValue (0));
  m_mpduAggregator = m_factory.Create<MpduAggregator> ();
  m_low->SetMpduAggregator (m_mpduAggregator);

  m_edca->GetEdcaQueue ()->Enqueue (pkt, hdr);
  packet = m_low->PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, 0);

  result = (packet != 0);
  NS_TEST_EXPECT_MSG_EQ (result, false, "maximum aggregated frame size check failed");

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

  /*
   * Aggregation does not occur zhen there is no more packets in the queue.
   * It checks whether MSDU aggregation has been rejected because there is no packets ready in the queue (returned packet should be equal to 0).
   * This test is needed to ensure that there is no issue when the queue is empty.
   */
  m_factory = ObjectFactory ();
  m_factory.SetTypeId ("ns3::MpduStandardAggregator");
  m_factory.Set ("MaxAmpduSize", UintegerValue (4095));
  m_mpduAggregator = m_factory.Create<MpduAggregator> ();
  m_low->SetMpduAggregator (m_mpduAggregator);

  m_edca->GetEdcaQueue ()->Remove (pkt);
  m_edca->GetEdcaQueue ()->Remove (pkt);
  packet = m_low->PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, 0);

  result = (packet != 0);
  NS_TEST_EXPECT_MSG_EQ (result, false, "aggregation failed to stop as queue is empty");
  Simulator::Destroy ();
}


//-----------------------------------------------------------------------------
class WifiAggregationTestSuite : public TestSuite
{
public:
  WifiAggregationTestSuite ();
};

WifiAggregationTestSuite::WifiAggregationTestSuite ()
  : TestSuite ("aggregation-wifi", UNIT)
{
  AddTestCase (new TwoLevelAggregationTest, TestCase::QUICK);
}

static WifiAggregationTestSuite g_wifiAggregationTestSuite;