Attachment #2005 for bug #1982

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





namespace ns3 {

#define GET_RANDOM_UINT32(RandomVariable) \
  static_cast<uint32_t> (RandomVariable->GetInteger (0, UINT32_MAX))

#define GET_RANDOM_UINT16(RandomVariable) \
  static_cast<uint16_t> (RandomVariable->GetInteger (0, UINT16_MAX))

#define GET_RANDOM_UINT8(RandomVariable) \
  static_cast<uint8_t> (RandomVariable->GetInteger (0, UINT8_MAX))

#define GET_RANDOM_UINT6(RandomVariable) \
  static_cast<uint8_t> (RandomVariable->GetInteger (0, UINT8_MAX >> 2))

class TcpHeaderGetSetTestCase : public TestCase
{
public:
  TcpHeaderGetSetTestCase (std::string name);
                           SequenceNumber32 sequenceNumber, SequenceNumber32 ackNumber,
                           uint8_t flags, uint16_t m_windowSize, uint16_t m_urgentPointer,
                           std::string name);
protected:
  uint16_t m_sourcePort;        //!< Source port
  uint16_t m_destinationPort;   //!< Destination port
  SequenceNumber32 m_sequenceNumber;  //!< Sequence number
  SequenceNumber32 m_ackNumber;       //!< ACK number
  uint8_t m_flags;              //!< Flags (really a uint6_t)
  uint16_t m_windowSize;        //!< Window size
  uint16_t m_urgentPointer;     //!< Urgent pointer

private:
  virtual void DoRun (void);
  virtual void DoTeardown (void);

  TcpHeader m_header;
  Buffer m_buffer;
};

TcpHeaderGetSetTestCase::TcpHeaderGetSetTestCase (std::string name) : TestCase (name)
  uint16_t sourcePort, uint16_t destinationPort,
  SequenceNumber32 sequenceNumber, SequenceNumber32 ackNumber,
  uint8_t flags, uint16_t windowSize, uint16_t urgentPointer,
  std::string name) : TestCase (name)
{
}
void TcpHeaderGetSetTestCase::DoRun (void)
{
  uint16_t sourcePort;        //!< Source port
  uint16_t destinationPort;   //!< Destination port
  SequenceNumber32 sequenceNumber;  //!< Sequence number
  SequenceNumber32 ackNumber;       //!< ACK number
  uint8_t flags;              //!< Flags (really a uint6_t)
  uint16_t windowSize;        //!< Window size
  uint16_t urgentPointer;     //!< Urgent pointer
  TcpHeader header;
  Buffer buffer;

  Ptr<UniformRandomVariable> x = CreateObject<UniformRandomVariable> ();
  for (uint32_t i = 0; i < 1000; ++i)
    {
      sourcePort = GET_RANDOM_UINT16 (x);
      destinationPort = GET_RANDOM_UINT16 (x);
      sequenceNumber = SequenceNumber32 (GET_RANDOM_UINT32 (x));
      ackNumber = SequenceNumber32 (GET_RANDOM_UINT32 (x));
      flags = GET_RANDOM_UINT6 (x);
      windowSize = GET_RANDOM_UINT16 (x);
      urgentPointer = GET_RANDOM_UINT16 (x);

      header.SetSourcePort (sourcePort);
      header.SetDestinationPort (destinationPort);
      header.SetSequenceNumber (sequenceNumber);
      header.SetAckNumber (ackNumber);
      header.SetFlags (flags);
      header.SetWindowSize (windowSize);
      header.SetUrgentPointer (urgentPointer);

      NS_TEST_ASSERT_MSG_EQ (header.GetLength (), 5, "TcpHeader without option is"
                         " not 5 word");

      buffer.AddAtStart (header.GetSerializedSize ());
      header.Serialize (buffer.Begin ());
}

      NS_TEST_ASSERT_MSG_EQ (sourcePort, header.GetSourcePort (),
{
  NS_TEST_ASSERT_MSG_EQ (m_sourcePort, m_header.GetSourcePort (),
                         "Different source port found");
      NS_TEST_ASSERT_MSG_EQ (destinationPort, header.GetDestinationPort (),
                         "Different destination port found");
      NS_TEST_ASSERT_MSG_EQ (sequenceNumber, header.GetSequenceNumber (),
                         "Different sequence number found");
      NS_TEST_ASSERT_MSG_EQ (ackNumber, header.GetAckNumber (),
                         "Different ack number found");
      NS_TEST_ASSERT_MSG_EQ (flags, header.GetFlags (),
                         "Different flags found");
      NS_TEST_ASSERT_MSG_EQ (windowSize, header.GetWindowSize (),
                         "Different window size found");
      NS_TEST_ASSERT_MSG_EQ (urgentPointer, header.GetUrgentPointer (),
                         "Different urgent pointer found");

      NS_TEST_ASSERT_MSG_EQ (header.GetLength (), 5, "TcpHeader without option is"
                         " not 5 word");

      TcpHeader copyHeader;

      copyHeader.Deserialize (buffer.Begin ());

      NS_TEST_ASSERT_MSG_EQ (sourcePort, copyHeader.GetSourcePort (),
                         "Different source port found in deserialized header");
      NS_TEST_ASSERT_MSG_EQ (destinationPort, copyHeader.GetDestinationPort (),
                         "Different destination port found in deserialized header");
      NS_TEST_ASSERT_MSG_EQ (sequenceNumber, copyHeader.GetSequenceNumber (),
                         "Different sequence number found in deserialized header");
      NS_TEST_ASSERT_MSG_EQ (ackNumber, copyHeader.GetAckNumber (),
                         "Different ack number found in deserialized header");
      NS_TEST_ASSERT_MSG_EQ (flags, copyHeader.GetFlags (),
                         "Different flags found in deserialized header");
      NS_TEST_ASSERT_MSG_EQ (windowSize, copyHeader.GetWindowSize (),
                         "Different window size found in deserialized header");
      NS_TEST_ASSERT_MSG_EQ (urgentPointer, copyHeader.GetUrgentPointer (),
                         "Different urgent pointer found in deserialized header");
    }
}

void TcpHeaderGetSetTestCase::DoTeardown (void)


}

#define GET_RANDOM_UINT32(RandomVariable) \
  static_cast<uint32_t> (RandomVariable->GetInteger (0, UINT32_MAX))

#define GET_RANDOM_UINT16(RandomVariable) \
  static_cast<uint16_t> (RandomVariable->GetInteger (0, UINT16_MAX))

#define GET_RANDOM_UINT8(RandomVariable) \
  static_cast<uint8_t> (RandomVariable->GetInteger (0, UINT8_MAX))

#define GET_RANDOM_UINT6(RandomVariable) \
  static_cast<uint8_t> (RandomVariable->GetInteger (0, UINT8_MAX >> 2))

static class TcpHeaderTestSuite : public TestSuite
{
public:
  TcpHeaderTestSuite ()
    : TestSuite ("tcp-header", UNIT)
  {
    AddTestCase (new TcpHeaderGetSetTestCase ("GetSet test cases"), TestCase::QUICK);
    AddTestCase (new TcpHeaderWithRFC793OptionTestCase ("Test for options in RFC 793"), TestCase::QUICK);
    for (uint32_t i = 0; i < 1000; ++i)
      {
        std::stringstream ss;
        ss << i;

        AddTestCase (new TcpHeaderGetSetTestCase (GET_RANDOM_UINT16 (x),
                                                  GET_RANDOM_UINT16 (x),
                                                  SequenceNumber32 (GET_RANDOM_UINT32 (x)),
                                                  SequenceNumber32 (GET_RANDOM_UINT32 (x)),
                                                  GET_RANDOM_UINT6 (x),
                                                  GET_RANDOM_UINT16 (x),
                                                  GET_RANDOM_UINT16 (x),
                                                  "Case number " + ss.str ()),
                     TestCase::QUICK);
      }

    AddTestCase (new TcpHeaderWithRFC793OptionTestCase ("Test for options in RFC 793"),
                 TestCase::QUICK);
  }

} g_TcpHeaderTestSuite;




class TcpOptionTSTestCase : public TestCase
{
public:
  TcpOptionTSTestCase (std::string name);

  void TestSerialize ();
  void TestDeserialize ();

};


TcpOptionTSTestCase::TcpOptionTSTestCase (std::string name)
                                          uint32_t echo)
  : TestCase (name)
{
  m_timestamp = timestamp;
  m_echo = echo;
}

void
TcpOptionTSTestCase::DoRun ()
{
  Ptr<UniformRandomVariable> x = CreateObject<UniformRandomVariable> ();

  for (uint32_t i = 0; i < 1000; ++i)
    {
      m_timestamp = x->GetInteger ();
      m_echo = x->GetInteger ();
      TestSerialize ();
      TestDeserialize ();
    }
}

void

        AddTestCase (new TcpOptionWSTestCase ("Testing window "
                                              "scale value", i), TestCase::QUICK);
      }
    AddTestCase (new TcpOptionTSTestCase ("Testing serialization of random values for timestamp"), TestCase::QUICK);
    Ptr<UniformRandomVariable> x = CreateObject<UniformRandomVariable> ();

    for (uint32_t i = 0; i < 1000; ++i)
      {
        AddTestCase (new TcpOptionTSTestCase ("Testing serialization of random "
                                              "values for timestamp",
                                              x->GetInteger (),
                                              x->GetInteger ()), TestCase::QUICK);
      }

  }

} g_TcpOptionTestSuite;

Return to bug 1982