/* -*- 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"

#include "packet-printer.h"

namespace ns3 {

template <int N>

class HistoryHeader : public Header

{

public:

  static uint32_t GetUid (void);

  HistoryHeader ();

  bool IsOk (void) const;

  std::string GetName (void) const;

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

  uint32_t GetSerializedSize (void) const;

  void Serialize (Buffer::Iterator start) const;

  uint32_t Deserialize (Buffer::Iterator start);

private:

  bool m_ok;

};

template <int N>

uint32_t

HistoryHeader<N>::GetUid (void)

{

  std::ostringstream oss;

  oss << N << "HistoryHeader.ns3";

  static uint32_t uid = AllocateUid<HistoryHeader<N> > (oss.str());

  return uid;

}

template <int N>

HistoryHeader<N>::HistoryHeader ()

  : m_ok (false)

{}

template <int N>

bool 

HistoryHeader<N>::IsOk (void) const

{

  return m_ok;

}

template <int N>

std::string 

HistoryHeader<N>::GetName (void) const

{

  std::ostringstream oss;

  oss << N;

  return oss.str ();

}

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)

{

  m_ok = true;

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

    {

      if (start.ReadU8 () != N)

        {

          m_ok = false;

        }

    }

  return N;

}

template <int N>

class HistoryTrailer : public Trailer

{

public:

  static uint32_t GetUid (void);

  HistoryTrailer ();

  bool IsOk (void) const;

  std::string GetName (void) const;

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

  uint32_t GetSerializedSize (void) const;

  void Serialize (Buffer::Iterator start) const;

  uint32_t Deserialize (Buffer::Iterator start);

private:

  bool m_ok;

};

template <int N>

uint32_t

HistoryTrailer<N>::GetUid (void)

{

  std::ostringstream oss;

  oss << N << "HistoryTrailer.ns3";

  static uint32_t uid = AllocateUid<HistoryTrailer<N> > (oss.str ());

  return uid;

}

template <int N>

HistoryTrailer<N>::HistoryTrailer ()

  : m_ok (false)

{}

template <int N>

bool

HistoryTrailer<N>::IsOk (void) const

{

  return m_ok;

}

template <int N>

std::string 

HistoryTrailer<N>::GetName (void) const

{

  std::ostringstream oss;

  oss << N;

  return oss.str ();

}

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)

{

  m_ok = true;

  start.Prev (N);

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

    {

      if (start.ReadU8 () != N)

        {

          m_ok = false;

        }

    }

  return N;

}

class PacketMetadataTest : public Test {

public:

  PacketMetadataTest ();

  virtual ~PacketMetadataTest ();

  virtual bool RunTests (void);

private:

  template <int N>

  void PrintHeader (std::ostream &os, uint32_t packetUid, uint32_t size, const HistoryHeader<N> *header);

  template <int N>

  void PrintTrailer (std::ostream &os, uint32_t packetUid, uint32_t size, const HistoryTrailer<N> *trailer);

  void PrintFragment (std::ostream &os,uint32_t packetUid,

                      uint32_t size,std::string & name, 

                      struct PacketPrinter::FragmentInformation info);

  void PrintPayload (std::ostream &os,uint32_t packetUid,

                     uint32_t size,

                     struct PacketPrinter::FragmentInformation info);

  template <int N>

  void RegisterHeader (void);

  template <int N>

  void RegisterTrailer (void);

  void CleanupPrints (void);

  bool Check (const char *file, int line, std::list<int> expected);

  bool m_headerError;

  bool m_trailerError;

  std::list<int> m_prints;

  PacketPrinter m_printer;

};

PacketMetadataTest::PacketMetadataTest ()

  : Test ("PacketMetadata")

{

  m_printer.SetPayloadPrinter (MakeCallback (&PacketMetadataTest::PrintPayload, this));

  m_printer.SetSeparator ("");

}

PacketMetadataTest::~PacketMetadataTest ()

{}

template <int N>

void 

PacketMetadataTest::RegisterHeader (void)

{

  static bool registered = false;

  if (!registered)

    {

      m_printer.SetHeaderPrinter (MakeCallback (&PacketMetadataTest::PrintHeader<N>, this),

                                  MakeCallback (&PacketMetadataTest::PrintFragment, this));

      registered = true;

    }

}

template <int N>

void 

PacketMetadataTest::RegisterTrailer (void)

{

  static bool registered = false;

  if (!registered)

    {

      m_printer.SetTrailerPrinter (MakeCallback (&PacketMetadataTest::PrintTrailer<N>, this),

                                   MakeCallback (&PacketMetadataTest::PrintFragment, this));

      registered = true;

    }

}

template <int N>

void 

PacketMetadataTest::PrintHeader (std::ostream &os, uint32_t packetUid, uint32_t size, 

                                const HistoryHeader<N> *header)

{

  if (!header->IsOk ())

    {

      m_headerError = true;

    }

  m_prints.push_back (N);

}

template <int N>

void 

PacketMetadataTest::PrintTrailer (std::ostream &os, uint32_t packetUid, uint32_t size, 

                                 const HistoryTrailer<N> *trailer)

{

  if (!trailer->IsOk ())

    {

      m_trailerError = true;

    }

  m_prints.push_back (N);

}

void 

PacketMetadataTest::PrintFragment (std::ostream &os,uint32_t packetUid,

                                  uint32_t size,std::string & name, 

                                  struct PacketPrinter::FragmentInformation info)

{

  m_prints.push_back (size - (info.end + info.start));

}

void 

PacketMetadataTest::PrintPayload (std::ostream &os,uint32_t packetUid,

                                 uint32_t size,

                                 struct PacketPrinter::FragmentInformation info)

{

  m_prints.push_back (size - (info.end + info.start));

}

void 

PacketMetadataTest::CleanupPrints (void)

{

  m_prints.clear ();

}

bool

PacketMetadataTest::Check (const char *file, int line, std::list<int> expected)

{

  if (m_headerError)

    {

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

                << ", line=" << line << std::endl;

      return false;

    }

  if (m_trailerError)

    {

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

                << ", line=" << line << std::endl;

      return false;

    }

  if (expected.size () != m_prints.size ())

    {

      goto error;

    }

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

         j = expected.begin (); 

       i != m_prints.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 = m_prints.begin (); 

       i != m_prints.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;

}

bool 

{

  m_headerError = false;

  m_trailerError = false;

  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);

  m_printer.PrintForward ();

  bool ok = Check (file, line, expected);

  CleanupPrints ();

  if (!ok)

    {

      return false;

    }

  m_printer.PrintBackward ();

  expected.reverse ();

  ok = Check (file, line, expected);

  CleanupPrints ();

  return ok;

}

#define ADD_HEADER(p, n)                        \

  {                                             \

    HistoryHeader<n> header;                    \

    RegisterHeader<n> ();                       \

  }

#define ADD_TRAILER(p, n)                       \

  {                                             \

    HistoryTrailer<n> trailer;                  \

    RegisterTrailer<n> ();                      \

  }

#define REM_HEADER(p, n)                        \

  {                                             \

    HistoryHeader<n> header;                    \

    RegisterHeader<n> ();                       \

  }

#define REM_TRAILER(p, n)                       \

  {                                             \

    HistoryTrailer<n> trailer;                  \

    RegisterTrailer<n> ();                      \

  }

#define CHECK_HISTORY(p, ...)                   \

  {                                             \

    if (!CheckHistory (p, __FILE__,             \

                      __LINE__, __VA_ARGS__))   \

      {                                         \

        ok = false;                             \

      }                                         \

    Buffer buffer;                              \

    if (!CheckHistory (otherPacket, __FILE__,   \

                      __LINE__, __VA_ARGS__))   \

      {                                         \

        ok = false;                             \

      }                                         \

  }

{

  ADD_HEADER (p, 10);

  return p;

}

bool

PacketMetadataTest::RunTests (void)

{

  bool ok = true;

  PacketMetadata::Enable ();

  ADD_TRAILER (p, 100);

  CHECK_HISTORY (p, 2, 10, 100);

  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);

  ADD_HEADER (p, 1);

  ADD_HEADER (p, 2);

  ADD_HEADER (p, 3);

  REM_HEADER (p, 3);

  CHECK_HISTORY (p, 3, 

                 2, 1, 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);

  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);

  ADD_HEADER (p, 1);

  ADD_HEADER (p, 2);

  ADD_HEADER (p, 3);

  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,