Attachment #2297 for bug #2302

View | Details | Raw Unified | Return to bug 2302
Collapse All | Expand All

(-)i/src/internet/test/tcp-error-model.cc (-1 / +1 lines)

Lines 58-64 TcpGeneralErrorModel::DoCorrupt (Ptr<Packet> p)	Link Here

  bool toDrop = ShouldDrop (ipHeader, tcpHeader, p->GetSize ());

  bool toDrop = ShouldDrop (ipHeader, tcpHeader, p->GetSize ());

  if (toDrop)

  if (toDrop && ! m_dropCallback.IsNull ())

      m_dropCallback (ipHeader, tcpHeader, p);

      m_dropCallback (ipHeader, tcpHeader, p);




    }
}

SequenceNumber32
TcpGeneralTest::GetHighestTxMark (SocketWho who)
{
  if (who == SENDER)
    {
      return DynamicCast<TcpSocketMsgBase> (m_senderSocket)->m_highTxMark;
    }
  else if (who == RECEIVER)
    {
      return DynamicCast<TcpSocketMsgBase> (m_receiverSocket)->m_highTxMark;
    }
  else
    {
      NS_FATAL_ERROR ("Not defined");
    }
}

uint32_t
TcpGeneralTest::GetInitialCwnd (SocketWho who)
{

(-)i/src/internet/test/tcp-general-test.h (+9 lines)

Lines 362-367 protected:	Link Here

362

  uint32_t GetSegSize (SocketWho who);

362

  uint32_t GetSegSize (SocketWho who);

363

364

/**

364

/**

365

   * \brief Get the highest tx mark of the node specified

366

367

   * \param who node to get the parameter from

368

369

   * \return mark of the specified node

370

*/

371

  SequenceNumber32 GetHighestTxMark (SocketWho who);

372

373

/**

365

   * \brief Get the retransmission threshold

374

   * \brief Get the retransmission threshold

366

   * \param who node to get the parameter from

375

   * \param who node to get the parameter from

367

   * \return retransmission threshold

376

   * \return retransmission threshold




  bool m_rttChanged;
  SequenceNumber32 m_highestTxSeq;
  uint32_t m_pktCount;
  uint32_t m_dataCount;
};

TcpRttEstimationTest::TcpRttEstimationTest (const std::string &desc, bool enableTs,

    m_enableTs (enableTs),
    m_rttChanged (false),
    m_highestTxSeq (0),
    m_pktCount (pktCount),
    m_dataCount (0)
{
}


      if (m_highestTxSeq < h.GetSequenceNumber ())
        {
          m_highestTxSeq = h.GetSequenceNumber ();
          m_dataCount = 0;
        }

      Ptr<RttEstimator> rttEstimator = GetRttEstimator (SENDER);
      NS_ASSERT (rttEstimator != 0);
      NS_LOG_DEBUG ("S Tx: seq=" << h.GetSequenceNumber () << " ack=" << h.GetAckNumber ());
      NS_TEST_ASSERT_MSG_NE (rttEstimator->GetEstimate (), Seconds (1),
                             "Default Estimate for the RTT");
    }

TcpRttEstimationTest::UpdatedRttHistory (const SequenceNumber32 & seq, uint32_t sz,
                                         bool isRetransmission, SocketWho who)
{
  if (sz == 0)
    {
      return;
    }

  if (seq < m_highestTxSeq)
    {
      NS_TEST_ASSERT_MSG_EQ (isRetransmission, true,
                             "A retransmission is not flagged as such");
    }
  else if (seq == m_highestTxSeq && m_dataCount == 0)
    {
      NS_TEST_ASSERT_MSG_EQ (isRetransmission, false,
                             "Incorrectly flagging seq as retransmission");
      m_dataCount++;
    }
  else if (seq == m_highestTxSeq && m_dataCount > 0)
    {
      NS_TEST_ASSERT_MSG_EQ (isRetransmission, true,
                             "A retransmission is not flagged as such");
    }

}

void
TcpRttEstimationTest::RttTrace (Time oldTime, Time newTime)
{
  NS_LOG_DEBUG ("Rtt changed to " << newTime.GetSeconds ());
  m_rttChanged = true;
}


}

//-----------------------------------------------------------------------------
class TcpRttEstimationWithLossTest : public TcpRttEstimationTest
{
public:
  TcpRttEstimationWithLossTest (const std::string &desc, bool enableTs,
                                uint32_t pktCount, std::vector<uint32_t> toDrop);

protected:
  Ptr<ErrorModel> CreateReceiverErrorModel ();

private:
  std::vector<uint32_t> m_toDrop;
};

TcpRttEstimationWithLossTest::TcpRttEstimationWithLossTest (const std::string &desc,
                                                            bool enableTs,
                                                            uint32_t pktCount,
                                                            std::vector<uint32_t> toDrop)
  : TcpRttEstimationTest (desc, enableTs, pktCount),
    m_toDrop (toDrop)
{

}

Ptr<ErrorModel>
TcpRttEstimationWithLossTest::CreateReceiverErrorModel ()
{
  Ptr<TcpSeqErrorModel> errorModel = CreateObject<TcpSeqErrorModel> ();

  std::vector<uint32_t>::iterator it;

  for (it = m_toDrop.begin (); it != m_toDrop.end (); ++it)
    {
      errorModel->AddSeqToKill (SequenceNumber32 ((*it)));
    }

  return errorModel;
}

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

static class TcpRttEstimationTestSuite : public TestSuite
{

                 TestCase::QUICK);
    AddTestCase (new TcpRttEstimationTest ("RTT estimation, no ts, some data", false, 10),
                 TestCase::QUICK);

    std::vector<uint32_t> toDrop;
    toDrop.push_back (501);

    AddTestCase (new TcpRttEstimationWithLossTest ("RTT estimation, no ts,"
                                                   " some data, with retr",
                                                   false, 10, toDrop),
                 TestCase::QUICK);
    AddTestCase (new TcpRttEstimationWithLossTest ("RTT estimation, ts,"
                                                   " some data, with retr",
                                                   true, 10, toDrop),
                 TestCase::QUICK);

    toDrop.push_back (501);
    AddTestCase (new TcpRttEstimationWithLossTest ("RTT estimation, no ts,"
                                                   " some data, with retr",
                                                   false, 10, toDrop),
                 TestCase::QUICK);
    AddTestCase (new TcpRttEstimationWithLossTest ("RTT estimation, ts,"
                                                   " some data, with retr",
                                                   true, 10, toDrop),
                 TestCase::QUICK);

    toDrop.push_back (54001);
    toDrop.push_back (58001);
    toDrop.push_back (58501);
    toDrop.push_back (60001);
    toDrop.push_back (68501);
    AddTestCase (new TcpRttEstimationWithLossTest ("RTT estimation, no ts,"
                                                   " a lot of data, with retr",
                                                   false, 1000, toDrop),
                 TestCase::QUICK);
    AddTestCase (new TcpRttEstimationWithLossTest ("RTT estimation, ts,"
                                                   " a lot of data, with retr",
                                                   true, 1000, toDrop),
                 TestCase::QUICK);
  }

} g_tcpRttEstimationTestSuite;

} // namespace ns3


Return to bug 2302