/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2006,2007 INRIA

 *

 * 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: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

 */

#ifdef RUN_SELF_TESTS

#include <stdarg.h>

#include <iostream>

#include <sstream>

#include "ns3/test.h"

#include "header.h"

#include "trailer.h"

#include "packet.h"

#include "packet-metadata.h"

using namespace ns3;

namespace {

class HistoryHeaderBase : public Header

{

public:

  static TypeId GetTypeId (void);

  HistoryHeaderBase ();

  bool IsOk (void) const;

protected:

  void ReportError (void);

private:

  bool m_ok;

};

TypeId 

HistoryHeaderBase::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::HistoryHeaderBase")

    .SetParent<Header> ()

    ;

  return tid;

}

HistoryHeaderBase::HistoryHeaderBase ()

  : m_ok (true)

{}

bool 

HistoryHeaderBase::IsOk (void) const

{

  return m_ok;

}

void 

HistoryHeaderBase::ReportError (void)

{

  m_ok = false;

}

template <int N>

class HistoryHeader : public HistoryHeaderBase

{

public:

  HistoryHeader ();

  static TypeId GetTypeId (void);

  virtual TypeId GetInstanceTypeId (void) const;

  virtual void Print (std::ostream &os) const;

  virtual uint32_t GetSerializedSize (void) const;

  virtual void Serialize (Buffer::Iterator start) const;

  virtual uint32_t Deserialize (Buffer::Iterator start);

};

template <int N>

HistoryHeader<N>::HistoryHeader ()

  : HistoryHeaderBase ()

{}

template <int N>

TypeId

HistoryHeader<N>::GetTypeId (void)

{

  std::ostringstream oss;

  oss << "ns3::HistoryHeader<"<<N<<">";

  static TypeId tid = TypeId (oss.str ().c_str ())

    .SetParent<HistoryHeaderBase> ()

    .AddConstructor<HistoryHeader<N> > ()

    ;

  return tid;

}

template <int N>

TypeId 

HistoryHeader<N>::GetInstanceTypeId (void) const

{

  return GetTypeId ();

}

template <int N>

void 

HistoryHeader<N>::Print (std::ostream &os) const

{

  NS_ASSERT (false);

}

template <int N>

uint32_t 

HistoryHeader<N>::GetSerializedSize (void) const

{

  return N;

}

template <int N>

void 

HistoryHeader<N>::Serialize (Buffer::Iterator start) const

{

  start.WriteU8 (N, N);

}

template <int N>

uint32_t

HistoryHeader<N>::Deserialize (Buffer::Iterator start)

{

  for (int i = 0; i < N; i++)

    {

      if (start.ReadU8 () != N)

        {

          ReportError ();

        }

    }

  return N;

}

class HistoryTrailerBase : public Trailer

{

public:

  static TypeId GetTypeId (void);

  HistoryTrailerBase ();

  bool IsOk (void) const;

protected:

  void ReportError (void);

private:

  bool m_ok;

};

TypeId 

HistoryTrailerBase::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::HistoryTrailerBase")

    .SetParent<Trailer> ()

    ;

  return tid;

}

HistoryTrailerBase::HistoryTrailerBase ()

  : m_ok (true)

{}

bool 

HistoryTrailerBase::IsOk (void) const

{

  return m_ok;

}

void 

HistoryTrailerBase::ReportError (void)

{

  m_ok = false;

}

template <int N>

class HistoryTrailer : public HistoryTrailerBase

{

public:

  HistoryTrailer ();

  bool IsOk (void) const;

  static TypeId GetTypeId (void);

  virtual TypeId GetInstanceTypeId (void) const;

  virtual void Print (std::ostream &os) const;

  virtual uint32_t GetSerializedSize (void) const;

  virtual void Serialize (Buffer::Iterator start) const;

  virtual uint32_t Deserialize (Buffer::Iterator start);

private:

  bool m_ok;

};

template <int N>

HistoryTrailer<N>::HistoryTrailer ()

{}

template <int N>

TypeId

HistoryTrailer<N>::GetTypeId (void)

{

  std::ostringstream oss;

  oss << "ns3::HistoryTrailer<"<<N<<">";

  static TypeId tid = TypeId (oss.str ().c_str ())

    .SetParent<HistoryTrailerBase> ()

    .AddConstructor<HistoryTrailer<N> > ()

    ;

  return tid;

}

template <int N>

TypeId 

HistoryTrailer<N>::GetInstanceTypeId (void) const

{

  return GetTypeId ();

}

template <int N>

void 

HistoryTrailer<N>::Print (std::ostream &os) const

{

  NS_ASSERT (false);

}

template <int N>

uint32_t 

HistoryTrailer<N>::GetSerializedSize (void) const

{

  return N;

}

template <int N>

void 

HistoryTrailer<N>::Serialize (Buffer::Iterator start) const

{

  start.Prev (N);

  start.WriteU8 (N, N);

}

template <int N>

uint32_t

HistoryTrailer<N>::Deserialize (Buffer::Iterator start)

{

  start.Prev (N);

  for (int i = 0; i < N; i++)

    {

      if (start.ReadU8 () != N)

        {

          ReportError ();

        }

    }

  return N;

}

}

namespace ns3 {

class PacketMetadataTest : public Test {

public:

  PacketMetadataTest ();

  virtual ~PacketMetadataTest ();

  bool CheckHistory (Ptr<Packet> p, const char *file, int line, uint32_t n, ...);

  virtual bool RunTests (void);

private:

  Ptr<Packet> DoAddHeader (Ptr<Packet> p);

};

PacketMetadataTest::PacketMetadataTest ()

  : Test ("PacketMetadata")

{}

PacketMetadataTest::~PacketMetadataTest ()

{}

bool 

PacketMetadataTest::CheckHistory (Ptr<Packet> p, const char *file, int line, uint32_t n, ...)

{

  std::list<int> expected;

  va_list ap;

  va_start (ap, n);

  for (uint32_t j = 0; j < n; j++)

    {

      int v = va_arg (ap, int);

      expected.push_back (v);

    }

  va_end (ap);

  PacketMetadata::ItemIterator k = p->BeginItem ();

  std::list<int> got;

  while (k.HasNext ())

    {

      struct PacketMetadata::Item item = k.Next ();

      if (item.isFragment || item.type == PacketMetadata::Item::PAYLOAD)

        {

          got.push_back (item.currentSize);

          continue;

        }

      if (item.type == PacketMetadata::Item::HEADER)

        {

          Callback<ObjectBase *> constructor = item.tid.GetConstructor ();

          HistoryHeaderBase *header = dynamic_cast<HistoryHeaderBase *> (constructor ());

          if (header == 0)

            {

              goto error;

            }

          header->Deserialize (item.current);

          if (!header->IsOk ())

            {

              delete header;

              goto error;

            }

          delete header;

        }

      else if (item.type == PacketMetadata::Item::TRAILER)

        {

          Callback<ObjectBase *> constructor = item.tid.GetConstructor ();

          HistoryTrailerBase *trailer = dynamic_cast<HistoryTrailerBase *> (constructor ());

          if (trailer == 0)

            {

              goto error;

            }

          trailer->Deserialize (item.current);

          if (!trailer->IsOk ())

            {

              delete trailer;

              goto error;

            }

          delete trailer;

        }

      got.push_back (item.currentSize);

    }

  for (std::list<int>::iterator i = got.begin (),

         j = expected.begin (); 

       i != got.end (); i++, j++)

    {

      NS_ASSERT (j != expected.end ());

      if (*j != *i)

        {

          goto error;

        }

    }

  return true;

 error:

  Failure () << "PacketMetadata error. file="<< file 

            << ", line=" << line << ", got:\"";

  for (std::list<int>::iterator i = got.begin (); 

       i != got.end (); i++)

    {

      Failure () << *i << ", ";

    }

  Failure () << "\", expected: \"";

  for (std::list<int>::iterator j = expected.begin ();

       j != expected.end (); j++)

    {

      Failure () << *j << ", ";

    }

  Failure () << "\"" << std::endl;

  return false;

}

#define ADD_HEADER(p, n)                        \

  {                                             \

    HistoryHeader<n> header;                    \

    p->AddHeader (header);                      \

  }

#define ADD_TRAILER(p, n)                       \

  {                                             \

    HistoryTrailer<n> trailer;                  \

    p->AddTrailer (trailer);                    \

  }

#define REM_HEADER(p, n)                        \

  {                                             \

    HistoryHeader<n> header;                    \

    p->RemoveHeader (header);                   \

  }

#define REM_TRAILER(p, n)                       \

  {                                             \

    HistoryTrailer<n> trailer;                  \

    p->RemoveTrailer (trailer);                 \

  }

#define CHECK_HISTORY(p, ...)                   \

  {                                             \

    if (!CheckHistory (p, __FILE__,             \

                      __LINE__, __VA_ARGS__))   \

      {                                         \

        result = false;                         \

      }                                         \

    Buffer buffer;                              \

    buffer = p->Serialize ();                   \

    Ptr<Packet> otherPacket = Create<Packet> ();\

    otherPacket->Deserialize  (buffer);         \

    if (!CheckHistory (otherPacket, __FILE__,   \

                      __LINE__, __VA_ARGS__))   \

      {                                         \

        result = false;                         \

      }                                         \

  }

Ptr<Packet>

PacketMetadataTest::DoAddHeader (Ptr<Packet> p)

{

  ADD_HEADER (p, 10);

  return p;

}

bool

PacketMetadataTest::RunTests (void)

{

  bool result = true;

  PacketMetadata::Enable ();

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

  Ptr<Packet> p1 = Create<Packet> (0);

  p = Create<Packet> (10);

  ADD_TRAILER (p, 100);

  CHECK_HISTORY (p, 2, 10, 100);

  p = Create<Packet> (10);

  ADD_HEADER (p, 1);

  ADD_HEADER (p, 2);

  ADD_HEADER (p, 3);

  CHECK_HISTORY (p, 4, 

                 3, 2, 1, 10);

  ADD_HEADER (p, 5);

  CHECK_HISTORY (p, 5, 

                 5, 3, 2, 1, 10);

  ADD_HEADER (p, 6);

  CHECK_HISTORY (p, 6, 

                 6, 5, 3, 2, 1, 10);

  p = Create<Packet> (10);

  ADD_HEADER (p, 1);

  ADD_HEADER (p, 2);

  ADD_HEADER (p, 3);

  REM_HEADER (p, 3);

  CHECK_HISTORY (p, 3, 

                 2, 1, 10);

  p = Create<Packet> (10);

  ADD_HEADER (p, 1);

  ADD_HEADER (p, 2);

  ADD_HEADER (p, 3);

  REM_HEADER (p, 3);

  REM_HEADER (p, 2);

  CHECK_HISTORY (p, 2, 

                 1, 10);

  p = Create<Packet> (10);

  ADD_HEADER (p, 1);

  ADD_HEADER (p, 2);

  ADD_HEADER (p, 3);

  REM_HEADER (p, 3);

  REM_HEADER (p, 2);

  REM_HEADER (p, 1);

  CHECK_HISTORY (p, 1, 10);

  p = Create<Packet> (10);

  ADD_HEADER (p, 1);

  ADD_HEADER (p, 2);

  ADD_HEADER (p, 3);

  p1 = p->Copy ();

  REM_HEADER (p1, 3);

  REM_HEADER (p1, 2);

  REM_HEADER (p1, 1);

  CHECK_HISTORY (p1, 1, 10);

  CHECK_HISTORY (p, 4, 

                 3, 2, 1, 10);

  ADD_HEADER (p1, 1);

  ADD_HEADER (p1, 2);

  CHECK_HISTORY (p1, 3, 

                 2, 1, 10);

  CHECK_HISTORY (p, 4, 

                 3, 2, 1, 10);

  ADD_HEADER (p, 3);

  CHECK_HISTORY (p, 5, 

                 3, 3, 2, 1, 10);

  ADD_TRAILER (p, 4);

  CHECK_HISTORY (p, 6, 

                 3, 3, 2, 1, 10, 4);

  ADD_TRAILER (p, 5);

  CHECK_HISTORY (p, 7, 

                 3, 3, 2, 1, 10, 4, 5);

  REM_HEADER (p, 3);

  CHECK_HISTORY (p, 6, 

                 3, 2, 1, 10, 4, 5);

  REM_TRAILER (p, 5);

  CHECK_HISTORY (p, 5, 

                 3, 2, 1, 10, 4);

  p1 = p->Copy ();

  REM_TRAILER (p, 4);

  CHECK_HISTORY (p, 4, 

                 3, 2, 1, 10);

  CHECK_HISTORY (p1, 5, 

                 3, 2, 1, 10, 4);

  p1->RemoveAtStart (3);

  CHECK_HISTORY (p1, 4, 

                 2, 1, 10, 4);

  p1->RemoveAtStart (1);

  CHECK_HISTORY (p1, 4, 

                 1, 1, 10, 4);

  p1->RemoveAtStart (1);

  CHECK_HISTORY (p1, 3,