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

/*

 * Copyright (c) 2009 CTTC

 *

 * 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: Nicola Baldo <nbaldo@cttc.es>

 */

#include <ns3/object.h>

#include <ns3/spectrum-value.h>

#include <ns3/spectrum-converter.h>

#include <ns3/log.h>

#include <ns3/test.h>

#include <iostream>

#include <math.h>

// NS_LOG_COMPONENT_DEFINE ("SpectrumValueTest");

namespace ns3 {

#define TOLERANCE 1e-6

class SpectrumValueTestCase : public TestCase

{

public:

  SpectrumValueTestCase (SpectrumValue a, SpectrumValue b, std::string name);

  virtual ~SpectrumValueTestCase ();

  virtual bool DoRun (void);

private:

  bool MoreOrLessEqual (SpectrumValue x, SpectrumValue y);

  SpectrumValue m_a;

  SpectrumValue m_b;

};

SpectrumValueTestCase::SpectrumValueTestCase (SpectrumValue a, SpectrumValue b, std::string name)

  : TestCase (name),

    m_a (a),

    m_b (b)

{

}

SpectrumValueTestCase::~SpectrumValueTestCase ()

{

}

bool

SpectrumValueTestCase::MoreOrLessEqual (SpectrumValue x, SpectrumValue y)

{

  SpectrumValue z = x - y;

  return (Norm (z) < TOLERANCE);

}

bool

SpectrumValueTestCase::DoRun (void)

{

  bool error = !MoreOrLessEqual (m_a, m_b);

  std::cerr << m_a << std::endl

            << m_b << std::endl;

  if (error)

    {

      std::ostringstream actualStream;

      actualStream << m_a;

      std::ostringstream limitStream;

      limitStream << m_b;

      UpdateErrorStatus (error);

      ReportTestFailure (std::string ("vector elements equal"),

                         actualStream.str (),

                         limitStream.str (),

                         std::string ("no message"),

                         __FILE__, __LINE__);

    }

  return error;

}

class SpectrumValueTestSuite : public TestSuite

{

public:

  SpectrumValueTestSuite ();

};

SpectrumValueTestSuite::SpectrumValueTestSuite ()

  : TestSuite ("spectrum-value", UNIT)

{

  // NS_LOG_INFO("creating SpectrumValueTestSuite");

  std::vector<double> freqs;

  for (int i = 1; i <= 5; i++)

    {

      freqs.push_back (i);

    }

  Ptr<SpectrumModel> f = Create<SpectrumModel> (freqs);

  SpectrumValue v1 (f), v2 (f), v3 (f), v4 (f), v5 (f), v6 (f), v7 (f), v8 (f), v9 (f), v10 (f);

  double nv1, nv2;

  double doubleValue;

  doubleValue =  1.12345600000000;

  v1[0] =  0.700539792840;

  v1[1] = -0.554277600423;

  v1[2] =  0.750309319469;

  v1[3] = -0.892299213192;

  v1[4] =  0.987045234885;

  v2[0] =  0.870441628737;

  v2[1] =  0.271419263880;

  v2[2] =  0.451557288312;

  v2[3] =  0.968992859395;

  v2[4] = -0.929186654705;

  v3[0] =  1.570981421577;

  v3[1] = -0.282858336543;

  v3[2] =  1.201866607781;

  v3[3] =  0.076693646203;

  v3[4] =  0.057858580180;

  v4[0] = -0.169901835897;

  v4[1] = -0.825696864302;

  v4[2] =  0.298752031158;

  v4[3] = -1.861292072588;

  v4[4] =  1.916231889590;

  v5[0] =  0.609778998275;

  v5[1] = -0.150441618292;

  v5[2] =  0.338807641695;

  v5[3] = -0.864631566028;

  v5[4] = -0.917149259846;

  v6[0] =  0.804809615846;

  v6[1] = -2.042145397125;

  v6[2] =  1.661603829438;

  v6[3] = -0.920852207053;

  v6[4] = -1.062267984465;

  v7[0] =  1.823995792840;

  v7[1] =  0.569178399577;

  v7[2] =  1.873765319469;

  v7[3] =  0.231156786808;

  v7[4] =  2.110501234885;

  v8[0] = -0.422916207160;

  v8[1] = -1.677733600423;

  v8[2] = -0.373146680531;

  v8[3] = -2.015755213192;

  v8[4] = -0.136410765115;

  v9[0] =  0.787025633505;

  v9[1] = -0.622706495860;

  v9[2] =  0.842939506814;

  v9[3] = -1.002458904856;

  v9[4] =  1.108901891403;

  v10[0] =  0.623557836569;

  v10[1] = -0.493368320987;

  v10[2] =  0.667858215604;

  v10[3] = -0.794244913190;

  v10[4] =  0.878579343459;

  nv1 =  1.76957619675970;

  nv2 =  1.68451062071783;

  // std::cerr.precision(15);

  // std::cerr<< nv1 << " "<<   v1.Norm() << std::endl;

  SpectrumValue tv3 (f), tv4 (f), tv5 (f), tv6 (f);

  tv3 = v1 + v2;

  tv4 = v1 - v2;

  tv5 = v1 * v2;

  tv6 = v1 / v2;

  AddTestCase (new SpectrumValueTestCase (tv3, v3, " tv3 = v1 + v2"));

  AddTestCase (new SpectrumValueTestCase (tv4, v4, " tv4 = v1 - v2"));

  AddTestCase (new SpectrumValueTestCase (tv5, v5, " tv5 = v1 * v2"));

  AddTestCase (new SpectrumValueTestCase (tv6, v6, " tv6 = v1 / v2"));

  // std::cerr << v6 << std::endl;

  // std::cerr << tv6 << std::endl;

  tv3 = v1;

  tv4 = v1;

  tv5 = v1;

  tv6 = v1;

  tv3 += v2;

  tv4 -= v2;

  tv5 *= v2;

  tv6 /= v2;

  AddTestCase (new SpectrumValueTestCase (tv3, v3, "tv3 += v2"));

  AddTestCase (new SpectrumValueTestCase (tv4, v4, "tv4 -= v2"));

  AddTestCase (new SpectrumValueTestCase (tv5, v5, "tv5 *= v2"));

  AddTestCase (new SpectrumValueTestCase (tv6, v6, "tv6 /= v2"));

  SpectrumValue tv7a (f), tv8a (f), tv9a (f), tv10a (f);

  tv7a = v1 + doubleValue;

  tv8a = v1 - doubleValue;

  tv9a = v1 * doubleValue;

  tv10a = v1 / doubleValue;

  AddTestCase (new SpectrumValueTestCase (tv7a, v7, "tv7a = v1 + doubleValue"));

  AddTestCase (new SpectrumValueTestCase (tv8a, v8, "tv8a = v1 - doubleValue"));

  AddTestCase (new SpectrumValueTestCase (tv9a, v9, "tv9a = v1 * doubleValue"));

  AddTestCase (new SpectrumValueTestCase (tv10a, v10, "tv10a = v1 / doubleValue"));

  SpectrumValue tv7b (f), tv8b (f), tv9b (f), tv10b (f);

  tv7b =  doubleValue + v1;

  tv8b =  doubleValue - v1;

  tv9b =  doubleValue * v1;

  tv10b = doubleValue / v1;

  AddTestCase (new SpectrumValueTestCase (tv7b, v7, "tv7b =  doubleValue + v1"));

  AddTestCase (new SpectrumValueTestCase (tv8b, v8, "tv8b =  doubleValue - v1"));

  AddTestCase (new SpectrumValueTestCase (tv9b, v9, "tv9b =  doubleValue * v1"));

  AddTestCase (new SpectrumValueTestCase (tv10b, v10, "tv10b = doubleValue / v1"));

  SpectrumValue v1ls3 (f), v1rs3 (f);

  SpectrumValue tv1ls3 (f), tv1rs3 (f);

  v1ls3[0] = v1[3];

  v1ls3[1] = v1[4];

  tv1ls3 = v1 << 3;

  AddTestCase (new SpectrumValueTestCase (tv1ls3, v1ls3, "tv1ls3 = v1 << 3"));

  v1rs3[3] = v1[0];

  v1rs3[4] = v1[1];

  tv1rs3 = v1 >> 3;

  AddTestCase (new SpectrumValueTestCase (tv1rs3, v1rs3, "tv1rs3 = v1 >> 3"));

}

class SpectrumConverterTestSuite : public TestSuite

{

public:

  SpectrumConverterTestSuite ();

};

SpectrumConverterTestSuite::SpectrumConverterTestSuite ()

  : TestSuite ("spectrum-converter", UNIT)

{

  double f;

  std::vector<double> f1;

  for (f = 3; f <= 7; f += 2)

    {

      f1.push_back (f);

    }

  Ptr<SpectrumModel> sof1 = Create<SpectrumModel> (f1);

  std::vector<double> f2;

  for (f = 2; f <= 8; f += 1)

    {

      f2.push_back (f);

    }

  Ptr<SpectrumModel> sof2 = Create<SpectrumModel> (f2);

  Ptr<SpectrumValue> res;

  Ptr<SpectrumValue> v1 = Create<SpectrumValue> (sof1);

  *v1 = 4;

  SpectrumConverter c12 (sof1, sof2);

  res = c12.Convert (v1);

  SpectrumValue t12 (sof2);

  t12 = 4;

  t12[0] = 2;

  t12[6] = 2;

//   NS_LOG_LOGIC(*v1);

//   NS_LOG_LOGIC(t12);

//   NS_LOG_LOGIC(*res);

  AddTestCase (new SpectrumValueTestCase (t12, *res, ""));

  // TEST_ASSERT(MoreOrLessEqual(t12, *res));

  Ptr<SpectrumValue> v2a = Create<SpectrumValue> (sof2);

  *v2a = -2;

  SpectrumConverter c21 (sof2, sof1);

  res = c21.Convert (v2a);

  SpectrumValue t21a (sof1);

  t21a = -2;

//   NS_LOG_LOGIC(*v2a);

//   NS_LOG_LOGIC(t21a);

//   NS_LOG_LOGIC(*res);

  AddTestCase (new SpectrumValueTestCase (t21a, *res, ""));

  // TEST_ASSERT(MoreOrLessEqual(t21a, *res));

  Ptr<SpectrumValue> v2b = Create<SpectrumValue> (sof2);

  (*v2b)[0] = 3;

  (*v2b)[1] = 5;

  (*v2b)[2] = 1;

  (*v2b)[3] = 2;

  (*v2b)[4] = 4;

  (*v2b)[5] = 6;

  (*v2b)[6] = 3;

  res = c21.Convert (v2b);

  SpectrumValue t21b (sof1);

  t21b[0] = 3 * 0.25 + 5 * 0.5 + 1 * 0.25;

  t21b[1] = 1 * 0.25 + 2 * 0.5 + 4 * 0.25;

  t21b[2] = 4 * 0.25 + 6 * 0.5 + 3 * 0.25;

//   NS_LOG_LOGIC(*v2b);

//   NS_LOG_LOGIC(t21b);

//   NS_LOG_LOGIC(*res);

  AddTestCase (new SpectrumValueTestCase (t21b, *res, ""));

}

// static instance of test suites

} // namespace ns3