three-gpp-http-client-server-test.cc

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Magister Solutions
 *
 * 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: Budiarto Herman <budiarto.herman@magister.fi>
 *
 */
 
#include <ns3/basic-data-calculators.h>
#include <ns3/config.h>
#include <ns3/error-model.h>
#include <ns3/integer.h>
#include <ns3/internet-stack-helper.h>
#include <ns3/ipv4-address-helper.h>
#include <ns3/ipv6-address-helper.h>
#include <ns3/log.h>
#include <ns3/mac48-address.h>
#include <ns3/node.h>
#include <ns3/nstime.h>
#include <ns3/packet.h>
#include <ns3/ptr.h>
#include <ns3/simple-channel.h>
#include <ns3/simple-net-device.h>
#include <ns3/tcp-congestion-ops.h>
#include <ns3/tcp-l4-protocol.h>
#include <ns3/test.h>
#include <ns3/three-gpp-http-client.h>
#include <ns3/three-gpp-http-header.h>
#include <ns3/three-gpp-http-helper.h>
#include <ns3/three-gpp-http-server.h>
 
#include <list>
#include <sstream>
 
NS_LOG_COMPONENT_DEFINE("ThreeGppHttpClientServerTest");
 
using namespace ns3;
 
// HTTP OBJECT TEST CASE //////////////////////////////////////////////////////
 
class ThreeGppHttpObjectTestCase : public TestCase
{
  public:
    ThreeGppHttpObjectTestCase(const std::string& name,
                               uint32_t rngRun,
                               const TypeId& tcpType,
                               const Time& channelDelay,
                               double bitErrorRate,
                               uint32_t mtuSize,
                               bool useIpv6);
 
  private:
    Ptr<Node> CreateSimpleInternetNode(Ptr<SimpleChannel> channel, Address& assignedAddress);
 
    // Inherited from TestCase base class.
    void DoRun() override;
    void DoTeardown() override;
 
    class ThreeGppHttpObjectTracker
    {
      public:
        ThreeGppHttpObjectTracker();
        void ObjectSent(uint32_t size);
        void PartReceived(uint32_t size);
        bool ObjectReceived(uint32_t& txSize, uint32_t& rxSize);
        bool IsEmpty() const;
        uint16_t GetNumOfObjectsReceived() const;
 
      private:
        std::list<uint32_t> m_objectsSize;
        uint32_t m_rxBuffer;
        uint16_t m_numOfObjectsReceived;
    };
 
    // The following defines one tracker for each HTTP object type.
    ThreeGppHttpObjectTracker m_requestObjectTracker;  
    ThreeGppHttpObjectTracker m_mainObjectTracker;     
    ThreeGppHttpObjectTracker m_embeddedObjectTracker; 
 
    // CALLBACK TO TRACE SOURCES.
 
    void ClientTxMainObjectRequestCallback(Ptr<const Packet> packet);
    void ClientTxEmbeddedObjectRequestCallback(Ptr<const Packet> packet);
    void ServerRxCallback(Ptr<const Packet> packet, const Address& from);
    void ServerMainObjectCallback(uint32_t size);
    void ClientRxMainObjectPacketCallback(Ptr<const Packet> packet);
    void ClientRxMainObjectCallback(Ptr<const ThreeGppHttpClient> httpClient,
                                    Ptr<const Packet> packet);
    void ServerEmbeddedObjectCallback(uint32_t size);
    void ClientRxEmbeddedObjectPacketCallback(Ptr<const Packet> packet);
    void ClientRxEmbeddedObjectCallback(Ptr<const ThreeGppHttpClient> httpClient,
                                        Ptr<const Packet> packet);
    void ClientStateTransitionCallback(const std::string& oldState, const std::string& newState);
    void ClientRxDelayCallback(const Time& delay, const Address& from);
    void ClientRxRttCallback(const Time& rtt, const Address& from);
    void DeviceDropCallback(Ptr<const Packet> packet);
    void ProgressCallback();
 
    // THE PARAMETERS OF THE TEST CASE.
 
    uint32_t m_rngRun;   
    TypeId m_tcpType;    
    Time m_channelDelay; 
    uint32_t m_mtuSize;  
    bool m_useIpv6;      
 
    // OTHER MEMBER VARIABLES.
 
    Ptr<RateErrorModel> m_errorModel;
    uint16_t m_numOfPagesReceived;
    uint16_t m_numOfPacketDrops;
    InternetStackHelper m_internetStackHelper;
    Ipv4AddressHelper m_ipv4AddressHelper;
    Ipv6AddressHelper m_ipv6AddressHelper;
    Ptr<MinMaxAvgTotalCalculator<double>> m_delayCalculator;
    Ptr<MinMaxAvgTotalCalculator<double>> m_rttCalculator;
 
}; // end of `class HttpClientServerTestCase`
 
ThreeGppHttpObjectTestCase::ThreeGppHttpObjectTestCase(const std::string& name,
                                                       uint32_t rngRun,
                                                       const TypeId& tcpType,
                                                       const Time& channelDelay,
                                                       double bitErrorRate,
                                                       uint32_t mtuSize,
                                                       bool useIpv6)
    : TestCase(name),
      m_rngRun(rngRun),
      m_tcpType(tcpType),
      m_channelDelay(channelDelay),
      m_mtuSize(mtuSize),
      m_useIpv6(useIpv6),
      m_numOfPagesReceived(0),
      m_numOfPacketDrops(0)
{
    NS_LOG_FUNCTION(this << GetName());
 
    // NS_ASSERT (tcpType.IsChildOf (TypeId::LookupByName ("ns3::TcpSocketBase")));
    NS_ASSERT(channelDelay.IsPositive());
 
    m_errorModel = CreateObject<RateErrorModel>();
    m_errorModel->SetRate(bitErrorRate);
    m_errorModel->SetUnit(RateErrorModel::ERROR_UNIT_BIT);
 
    m_ipv4AddressHelper.SetBase(Ipv4Address("10.0.0.0"),
                                Ipv4Mask("255.0.0.0"),
                                Ipv4Address("0.0.0.1"));
    m_ipv6AddressHelper.SetBase(Ipv6Address("2001:1::"), Ipv6Prefix(64), Ipv6Address("::1"));
 
    m_delayCalculator = CreateObject<MinMaxAvgTotalCalculator<double>>();
    m_rttCalculator = CreateObject<MinMaxAvgTotalCalculator<double>>();
}
 
Ptr<Node>
ThreeGppHttpObjectTestCase::CreateSimpleInternetNode(Ptr<SimpleChannel> channel,
                                                     Address& assignedAddress)
{
    NS_LOG_FUNCTION(this << channel);
 
    Ptr<SimpleNetDevice> dev = CreateObject<SimpleNetDevice>();
    dev->SetAddress(Mac48Address::Allocate());
    dev->SetChannel(channel);
    dev->SetReceiveErrorModel(m_errorModel);
 
    Ptr<Node> node = CreateObject<Node>();
    node->AddDevice(dev);
    m_internetStackHelper.Install(node);
 
    // Assign IP address according to the selected Ip version.
    if (m_useIpv6)
    {
        Ipv6InterfaceContainer ipv6Ifs = m_ipv6AddressHelper.Assign(NetDeviceContainer(dev));
        NS_ASSERT(ipv6Ifs.GetN() == 1);
        assignedAddress = ipv6Ifs.GetAddress(0, 0);
    }
    else
    {
        Ipv4InterfaceContainer ipv4Ifs = m_ipv4AddressHelper.Assign(NetDeviceContainer(dev));
        NS_ASSERT(ipv4Ifs.GetN() == 1);
        assignedAddress = ipv4Ifs.GetAddress(0, 0);
    }
 
    NS_LOG_DEBUG(this << " node is assigned to " << assignedAddress << ".");
 
    // Set the TCP algorithm.
    Ptr<TcpL4Protocol> tcp = node->GetObject<TcpL4Protocol>();
    tcp->SetAttribute("SocketType", TypeIdValue(m_tcpType));
 
    // Connect with the trace source that informs about packet drop due to error.
    dev->TraceConnectWithoutContext(
        "PhyRxDrop",
        MakeCallback(&ThreeGppHttpObjectTestCase::DeviceDropCallback, this));
 
    return node;
}
 
void
ThreeGppHttpObjectTestCase::DoRun()
{
    NS_LOG_FUNCTION(this << GetName());
    Config::SetGlobal("RngRun", UintegerValue(m_rngRun));
    NS_LOG_INFO(this << " Running test case " << GetName());
 
    /*
     * Create topology:
     *
     *     Server Node                  Client Node
     * +-----------------+          +-----------------+
     * |   HTTP Server   |          |   HTTP Client   |
     * |   Application   |          |   Application   |
     * +-----------------+          +-----------------+
     * |       TCP       |          |       TCP       |
     * +-----------------+          +-----------------+
     * |     IPv4/v6     |          |     IPv4/v6     |
     * +-----------------+          +-----------------+
     * |  Simple NetDev  |          |  Simple NetDev  |
     * +-----------------+          +-----------------+
     *          |                            |
     *          |                            |
     *          +----------------------------+
     *                  Simple Channel
     */
 
    // Channel.
    Ptr<SimpleChannel> channel = CreateObject<SimpleChannel>();
    channel->SetAttribute("Delay", TimeValue(m_channelDelay));
 
    // Server node.
    Address serverAddress;
    Ptr<Node> serverNode = CreateSimpleInternetNode(channel, serverAddress);
    ThreeGppHttpServerHelper serverHelper(serverAddress);
    ApplicationContainer serverApplications = serverHelper.Install(serverNode);
    NS_TEST_ASSERT_MSG_EQ(serverApplications.GetN(),
                          1,
                          "Invalid number of HTTP servers has been installed");
    Ptr<ThreeGppHttpServer> httpServer = serverApplications.Get(0)->GetObject<ThreeGppHttpServer>();
    NS_TEST_ASSERT_MSG_NE(httpServer,
                          nullptr,
                          "HTTP server installation fails to produce a proper type");
    httpServer->SetMtuSize(m_mtuSize);
 
    // Client node.
    Address clientAddress;
    Ptr<Node> clientNode = CreateSimpleInternetNode(channel, clientAddress);
    ThreeGppHttpClientHelper clientHelper(serverAddress);
    ApplicationContainer clientApplications = clientHelper.Install(clientNode);
    NS_TEST_ASSERT_MSG_EQ(clientApplications.GetN(),
                          1,
                          "Invalid number of HTTP clients has been installed");
    Ptr<ThreeGppHttpClient> httpClient = clientApplications.Get(0)->GetObject<ThreeGppHttpClient>();
    NS_TEST_ASSERT_MSG_NE(httpClient,
                          nullptr,
                          "HTTP client installation fails to produce a proper type");
 
    // Uplink (requests) trace sources.
    bool traceSourceConnected = httpClient->TraceConnectWithoutContext(
        "TxMainObjectRequest",
        MakeCallback(&ThreeGppHttpObjectTestCase::ClientTxMainObjectRequestCallback, this));
    NS_ASSERT(traceSourceConnected);
    traceSourceConnected = httpClient->TraceConnectWithoutContext(
        "TxEmbeddedObjectRequest",
        MakeCallback(&ThreeGppHttpObjectTestCase::ClientTxEmbeddedObjectRequestCallback, this));
    NS_ASSERT(traceSourceConnected);
    traceSourceConnected = httpServer->TraceConnectWithoutContext(
        "Rx",
        MakeCallback(&ThreeGppHttpObjectTestCase::ServerRxCallback, this));
    NS_ASSERT(traceSourceConnected);
 
    // Downlink (main objects) trace sources.
    traceSourceConnected = httpServer->TraceConnectWithoutContext(
        "MainObject",
        MakeCallback(&ThreeGppHttpObjectTestCase::ServerMainObjectCallback, this));
    NS_ASSERT(traceSourceConnected);
    traceSourceConnected = httpClient->TraceConnectWithoutContext(
        "RxMainObjectPacket",
        MakeCallback(&ThreeGppHttpObjectTestCase::ClientRxMainObjectPacketCallback, this));
    NS_ASSERT(traceSourceConnected);
    traceSourceConnected = httpClient->TraceConnectWithoutContext(
        "RxMainObject",
        MakeCallback(&ThreeGppHttpObjectTestCase::ClientRxMainObjectCallback, this));
    NS_ASSERT(traceSourceConnected);
 
    // Downlink (embedded objects) trace sources.
    traceSourceConnected = httpServer->TraceConnectWithoutContext(
        "EmbeddedObject",
        MakeCallback(&ThreeGppHttpObjectTestCase::ServerEmbeddedObjectCallback, this));
    NS_ASSERT(traceSourceConnected);
 
    traceSourceConnected = httpClient->TraceConnectWithoutContext(
        "RxEmbeddedObjectPacket",
        MakeCallback(&ThreeGppHttpObjectTestCase::ClientRxEmbeddedObjectPacketCallback, this));
    NS_ASSERT(traceSourceConnected);
 
    traceSourceConnected = httpClient->TraceConnectWithoutContext(
        "RxEmbeddedObject",
        MakeCallback(&ThreeGppHttpObjectTestCase::ClientRxEmbeddedObjectCallback, this));
    NS_ASSERT(traceSourceConnected);
 
    // Other trace sources.
    traceSourceConnected = httpClient->TraceConnectWithoutContext(
        "StateTransition",
        MakeCallback(&ThreeGppHttpObjectTestCase::ClientStateTransitionCallback, this));
    NS_ASSERT(traceSourceConnected);
    traceSourceConnected = httpClient->TraceConnectWithoutContext(
        "RxDelay",
        MakeCallback(&ThreeGppHttpObjectTestCase::ClientRxDelayCallback, this));
    NS_ASSERT(traceSourceConnected);
    traceSourceConnected = httpClient->TraceConnectWithoutContext(
        "RxRtt",
        MakeCallback(&ThreeGppHttpObjectTestCase::ClientRxRttCallback, this));
    NS_ASSERT(traceSourceConnected);
 
    Simulator::Schedule(Seconds(1.0), &ThreeGppHttpObjectTestCase::ProgressCallback, this);
 
    /*
     * Here we don't set the simulation stop time. During the run, the simulation
     * will stop immediately after the client has completely received the third
     * web page.
     */
    Simulator::Run();
 
    // Dump some statistical information about the simulation.
    NS_LOG_INFO(this << " Total request objects received: "
                     << m_requestObjectTracker.GetNumOfObjectsReceived() << " object(s).");
    NS_LOG_INFO(this << " Total main objects received: "
                     << m_mainObjectTracker.GetNumOfObjectsReceived() << " object(s).");
    NS_LOG_INFO(this << " Total embedded objects received: "
                     << m_embeddedObjectTracker.GetNumOfObjectsReceived() << " object(s).");
    NS_LOG_INFO(this << " One-trip delays:"
                     << " average=" << m_delayCalculator->getMean() << " min="
                     << m_delayCalculator->getMin() << " max=" << m_delayCalculator->getMax());
    NS_LOG_INFO(this << " Round-trip delays:"
                     << " average=" << m_rttCalculator->getMean() << " min="
                     << m_rttCalculator->getMin() << " max=" << m_rttCalculator->getMax());
    NS_LOG_INFO(this << " Number of packets dropped by the devices: " << m_numOfPacketDrops
                     << " packet(s).");
 
    // Some post-simulation tests.
    NS_TEST_EXPECT_MSG_EQ(m_numOfPagesReceived, 3, "Unexpected number of web pages processed.");
    NS_TEST_EXPECT_MSG_EQ(m_requestObjectTracker.IsEmpty(),
                          true,
                          "Tracker of request objects detected irrelevant packet(s).");
    NS_TEST_EXPECT_MSG_EQ(m_mainObjectTracker.IsEmpty(),
                          true,
                          "Tracker of main objects detected irrelevant packet(s).");
    NS_TEST_EXPECT_MSG_EQ(m_embeddedObjectTracker.IsEmpty(),
                          true,
                          "Tracker of embedded objects detected irrelevant packet(s).");
 
    Simulator::Destroy();
 
} // end of `void HttpClientServerTestCase::DoRun ()`
 
void
ThreeGppHttpObjectTestCase::DoTeardown()
{
    NS_LOG_FUNCTION(this << GetName());
}
 
ThreeGppHttpObjectTestCase::ThreeGppHttpObjectTracker::ThreeGppHttpObjectTracker()
    : m_rxBuffer(0),
      m_numOfObjectsReceived(0)
{
    NS_LOG_FUNCTION(this);
}
 
void
ThreeGppHttpObjectTestCase::ThreeGppHttpObjectTracker::ObjectSent(uint32_t size)
{
    NS_LOG_FUNCTION(this << size);
    m_objectsSize.push_back(size);
}
 
void
ThreeGppHttpObjectTestCase::ThreeGppHttpObjectTracker::PartReceived(uint32_t size)
{
    NS_LOG_FUNCTION(this << size);
    m_rxBuffer += size;
}
 
bool
ThreeGppHttpObjectTestCase::ThreeGppHttpObjectTracker::ObjectReceived(uint32_t& txSize,
                                                                      uint32_t& rxSize)
{
    NS_LOG_FUNCTION(this);
 
    if (m_objectsSize.empty())
    {
        return false;
    }
 
    // Set output values.
    txSize = m_objectsSize.front();
    rxSize = m_rxBuffer;
 
    // Reset counters.
    m_objectsSize.pop_front();
    m_rxBuffer = 0;
    m_numOfObjectsReceived++;
 
    return true;
}
 
bool
ThreeGppHttpObjectTestCase::ThreeGppHttpObjectTracker::IsEmpty() const
{
    return (m_objectsSize.empty() && (m_rxBuffer == 0));
}
 
uint16_t
ThreeGppHttpObjectTestCase::ThreeGppHttpObjectTracker::GetNumOfObjectsReceived() const
{
    return m_numOfObjectsReceived;
}
 
void
ThreeGppHttpObjectTestCase::ClientTxMainObjectRequestCallback(Ptr<const Packet> packet)
{
    NS_LOG_FUNCTION(this << packet << packet->GetSize());
    m_requestObjectTracker.ObjectSent(packet->GetSize());
}
 
void
ThreeGppHttpObjectTestCase::ClientTxEmbeddedObjectRequestCallback(Ptr<const Packet> packet)
{
    NS_LOG_FUNCTION(this << packet << packet->GetSize());
    m_requestObjectTracker.ObjectSent(packet->GetSize());
}
 
void
ThreeGppHttpObjectTestCase::ServerRxCallback(Ptr<const Packet> packet, const Address& from)
{
    NS_LOG_FUNCTION(this << packet << packet->GetSize() << from);
 
    // Check the header in packet
    Ptr<Packet> copy = packet->Copy();
    ThreeGppHttpHeader httpHeader;
    NS_TEST_ASSERT_MSG_EQ(copy->RemoveHeader(httpHeader),
                          22,
                          "Error finding ThreeGppHttpHeader in a packet received by the server");
    NS_TEST_ASSERT_MSG_GT(httpHeader.GetClientTs(),
                          Seconds(0.0),
                          "Request object's client TS is unexpectedly non-positive");
 
    m_requestObjectTracker.PartReceived(packet->GetSize());
 
    /*
     * Request objects are assumed to be small and to not typically split. So we
     * immediately follow by concluding the receive of a whole request object.
     */
    uint32_t txSize = 0;
    uint32_t rxSize = 0;
    bool isSent = m_requestObjectTracker.ObjectReceived(txSize, rxSize);
    NS_TEST_ASSERT_MSG_EQ(isSent, true, "Server receives one too many request object");
    NS_TEST_ASSERT_MSG_EQ(txSize,
                          rxSize,
                          "Transmitted size and received size of request object differ");
}
 
void
ThreeGppHttpObjectTestCase::ServerMainObjectCallback(uint32_t size)
{
    NS_LOG_FUNCTION(this << size);
    m_mainObjectTracker.ObjectSent(size);
}
 
void
ThreeGppHttpObjectTestCase::ClientRxMainObjectPacketCallback(Ptr<const Packet> packet)
{
    NS_LOG_FUNCTION(this << packet << packet->GetSize());
    m_mainObjectTracker.PartReceived(packet->GetSize());
}
 
void
ThreeGppHttpObjectTestCase::ClientRxMainObjectCallback(Ptr<const ThreeGppHttpClient> httpClient,
                                                       Ptr<const Packet> packet)
{
    NS_LOG_FUNCTION(this << httpClient << httpClient->GetNode()->GetId());
 
    // Verify the header in the packet.
    Ptr<Packet> copy = packet->Copy();
    ThreeGppHttpHeader httpHeader;
    NS_TEST_ASSERT_MSG_EQ(copy->RemoveHeader(httpHeader),
                          22,
                          "Error finding ThreeGppHttpHeader in a packet received by the server");
    NS_TEST_ASSERT_MSG_EQ(httpHeader.GetContentType(),
                          ThreeGppHttpHeader::MAIN_OBJECT,
                          "Invalid content type in the received packet");
    NS_TEST_ASSERT_MSG_GT(httpHeader.GetClientTs(),
                          Seconds(0.0),
                          "Main object's client TS is unexpectedly non-positive");
    NS_TEST_ASSERT_MSG_GT(httpHeader.GetServerTs(),
                          Seconds(0.0),
                          "Main object's server TS is unexpectedly non-positive");
 
    uint32_t txSize = 0;
    uint32_t rxSize = 0;
    bool isSent = m_mainObjectTracker.ObjectReceived(txSize, rxSize);
    NS_TEST_ASSERT_MSG_EQ(isSent, true, "Client receives one too many main object");
    NS_TEST_ASSERT_MSG_EQ(txSize,
                          rxSize,
                          "Transmitted size and received size of main object differ");
    NS_TEST_ASSERT_MSG_EQ(httpHeader.GetContentLength(),
                          rxSize,
                          "Actual main object packet size and received size of main object differ");
}
 
void
ThreeGppHttpObjectTestCase::ServerEmbeddedObjectCallback(uint32_t size)
{
    NS_LOG_FUNCTION(this << size);
    m_embeddedObjectTracker.ObjectSent(size);
}
 
void
ThreeGppHttpObjectTestCase::ClientRxEmbeddedObjectPacketCallback(Ptr<const Packet> packet)
{
    NS_LOG_FUNCTION(this << packet << packet->GetSize());
    m_embeddedObjectTracker.PartReceived(packet->GetSize());
}
 
void
ThreeGppHttpObjectTestCase::ClientRxEmbeddedObjectCallback(Ptr<const ThreeGppHttpClient> httpClient,
                                                           Ptr<const Packet> packet)
{
    NS_LOG_FUNCTION(this << httpClient << httpClient->GetNode()->GetId());
 
    // Verify the header in the packet.
    Ptr<Packet> copy = packet->Copy();
    ThreeGppHttpHeader httpHeader;
    NS_TEST_ASSERT_MSG_EQ(copy->RemoveHeader(httpHeader),
                          22,
                          "Error finding ThreeGppHttpHeader in a packet received by the server");
    NS_TEST_ASSERT_MSG_EQ(httpHeader.GetContentType(),
                          ThreeGppHttpHeader::EMBEDDED_OBJECT,
                          "Invalid content type in the received packet");
    NS_TEST_ASSERT_MSG_GT(httpHeader.GetClientTs(),
                          Seconds(0.0),
                          "Embedded object's client TS is unexpectedly non-positive");
    NS_TEST_ASSERT_MSG_GT(httpHeader.GetServerTs(),
                          Seconds(0.0),
                          "Embedded object's server TS is unexpectedly non-positive");
 
    uint32_t txSize = 0;
    uint32_t rxSize = 0;
    bool isSent = m_embeddedObjectTracker.ObjectReceived(txSize, rxSize);
    NS_TEST_ASSERT_MSG_EQ(isSent, true, "Client receives one too many embedded object");
    NS_TEST_ASSERT_MSG_EQ(txSize,
                          rxSize,
                          "Transmitted size and received size of embedded object differ");
    NS_TEST_ASSERT_MSG_EQ(
        httpHeader.GetContentLength(),
        rxSize,
        "Actual embedded object packet size and received size of embedded object differ");
}
 
void
ThreeGppHttpObjectTestCase::ClientStateTransitionCallback(const std::string& oldState,
                                                          const std::string& newState)
{
    NS_LOG_FUNCTION(this << oldState << newState);
 
    if (newState == "READING")
    {
        m_numOfPagesReceived++;
 
        if (m_numOfPagesReceived >= 3)
        {
            // We have processed 3 web pages and that should be enough for this test.
            NS_LOG_LOGIC(this << " Test is stopping now.");
            Simulator::Stop();
        }
    }
}
 
void
ThreeGppHttpObjectTestCase::ProgressCallback()
{
    NS_LOG_INFO("Simulator time now: " << Simulator::Now().As(Time::S) << ".");
    Simulator::Schedule(Seconds(1.0), &ThreeGppHttpObjectTestCase::ProgressCallback, this);
}
 
void
ThreeGppHttpObjectTestCase::ClientRxDelayCallback(const Time& delay, const Address& from)
{
    NS_LOG_FUNCTION(this << delay.As(Time::S) << from);
    m_delayCalculator->Update(delay.GetSeconds());
}
 
void
ThreeGppHttpObjectTestCase::ClientRxRttCallback(const Time& rtt, const Address& from)
{
    NS_LOG_FUNCTION(this << rtt.As(Time::S) << from);
    m_rttCalculator->Update(rtt.GetSeconds());
}
 
void
ThreeGppHttpObjectTestCase::DeviceDropCallback(Ptr<const Packet> packet)
{
    NS_LOG_FUNCTION(this << packet << packet->GetSize());
    m_numOfPacketDrops++;
}
 
// TEST SUITE /////////////////////////////////////////////////////////////////
 
class ThreeGppHttpClientServerTestSuite : public TestSuite
{
  public:
    ThreeGppHttpClientServerTestSuite()
        : TestSuite("three-gpp-http-client-server-test", SYSTEM)
    {
        // LogComponentEnable ("ThreeGppHttpClientServerTest", LOG_INFO);
        // LogComponentEnable ("ThreeGppHttpClient", LOG_INFO);
        // LogComponentEnable ("ThreeGppHttpServer", LOG_INFO);
        // LogComponentEnableAll (LOG_PREFIX_ALL);
 
        Time channelDelay[] = {MilliSeconds(3), MilliSeconds(30), MilliSeconds(300)};
        double bitErrorRate[] = {0.0, 5.0e-6};
        uint32_t mtuSize[] = {536, 1460};
 
        uint32_t run = 1;
        while (run <= 100)
        {
            for (uint32_t i1 = 0; i1 < 3; i1++)
            {
                for (uint32_t i2 = 0; i2 < 2; i2++)
                {
                    for (uint32_t i3 = 0; i3 < 2; i3++)
                    {
                        AddHttpObjectTestCase(run++,
                                              channelDelay[i1],
                                              bitErrorRate[i2],
                                              mtuSize[i3],
                                              false);
                        AddHttpObjectTestCase(run++,
                                              channelDelay[i1],
                                              bitErrorRate[i2],
                                              mtuSize[i3],
                                              true);
                    }
                }
            }
        }
    }
 
  private:
    void AddHttpObjectTestCase(uint32_t rngRun,
                               const Time& channelDelay,
                               double bitErrorRate,
                               uint32_t mtuSize,
                               bool useIpv6)
    {
        std::ostringstream name;
        name << "Run #" << rngRun;
        name << " delay=" << channelDelay.As(Time::MS);
        name << " ber=" << bitErrorRate;
        name << " mtu=" << mtuSize;
 
        if (useIpv6)
        {
            name << " IPv6";
        }
        else
        {
            name << " IPv4";
        }
 
        // Assign higher fullness for tests with higher RngRun.
        TestCase::TestDuration testDuration = TestCase::QUICK;
        if (rngRun > 20)
        {
            testDuration = TestCase::EXTENSIVE;
        }
        if (rngRun > 50)
        {
            testDuration = TestCase::TAKES_FOREVER;
        }
 
        AddTestCase(new ThreeGppHttpObjectTestCase(name.str(),
                                                   rngRun,
                                                   TcpNewReno::GetTypeId(),
                                                   channelDelay,
                                                   bitErrorRate,
                                                   mtuSize,
                                                   useIpv6),
                    testDuration);
    }
 
}; // end of class `ThreeGppHttpClientServerTestSuite`
 
static ThreeGppHttpClientServerTestSuite g_httpClientServerTestSuiteInstance;