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

/*

 * Copyright (c) 2009 University of Washington

 *

 * 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

 */

#include "ns3/test.h"

#include "ns3/object.h"

#include "ns3/boolean.h"

#include "ns3/integer.h"

#include "ns3/uinteger.h"

#include "ns3/config.h"

#include "ns3/enum.h"

#include "ns3/string.h"

#include "ns3/random-variable-stream.h"

#include "ns3/double.h"

#include "ns3/object-vector.h"

#include "ns3/object-map.h"

#include "ns3/traced-value.h"

#include "ns3/callback.h"

#include "ns3/trace-source-accessor.h"

#include "ns3/pointer.h"

#include "ns3/object-factory.h"

#include "ns3/nstime.h"

using namespace ns3;

class ValueClassTest 

{

public:

  ValueClassTest () {}

private:

  int m_v;

};

bool operator != (const ValueClassTest &a, const ValueClassTest &b)

{

  return true;

}

std::ostream & operator << (std::ostream &os, ValueClassTest v)

{

  return os;

}

std::istream & operator >> (std::istream &is, ValueClassTest &v)

{

  return is;

}

ATTRIBUTE_HELPER_HEADER (ValueClassTest);

ATTRIBUTE_HELPER_CPP (ValueClassTest);

class Derived : public Object

{

public:

  static TypeId GetTypeId (void) {

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

      .AddConstructor<Derived> ()

      .SetParent<Object> ()

    ;

    return tid;

  }

  Derived () {}

};

NS_OBJECT_ENSURE_REGISTERED (Derived);

class AttributeObjectTest : public Object

{

public:

  enum Test_e {

    TEST_A,

    TEST_B,

    TEST_C

  };

  static TypeId GetTypeId (void) {

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

      .AddConstructor<AttributeObjectTest> ()

      .SetParent<Object> ()

      .HideFromDocumentation ()

      .AddAttribute ("TestBoolName", "help text",

                     BooleanValue (false),

                     MakeBooleanAccessor (&AttributeObjectTest::m_boolTest),

                     MakeBooleanChecker ())

      .AddAttribute ("TestBoolA", "help text",

                     BooleanValue (false),

                     MakeBooleanAccessor (&AttributeObjectTest::DoSetTestB,

                                          &AttributeObjectTest::DoGetTestB),

                     MakeBooleanChecker ())

      .AddAttribute ("TestInt16", "help text",

                     IntegerValue (-2),

                     MakeIntegerAccessor (&AttributeObjectTest::m_int16),

                     MakeIntegerChecker<int16_t> ())

      .AddAttribute ("TestInt16WithBounds", "help text",

                     IntegerValue (-2),

                     MakeIntegerAccessor (&AttributeObjectTest::m_int16WithBounds),

                     MakeIntegerChecker<int16_t> (-5, 10))

      .AddAttribute ("TestInt16SetGet", "help text",

                     IntegerValue (6),

                     MakeIntegerAccessor (&AttributeObjectTest::DoSetInt16,

                                          &AttributeObjectTest::DoGetInt16),

                     MakeIntegerChecker<int16_t> ())

      .AddAttribute ("TestUint8", "help text",

                     UintegerValue (1),

                     MakeUintegerAccessor (&AttributeObjectTest::m_uint8),

                     MakeUintegerChecker<uint8_t> ())

      .AddAttribute ("TestEnum", "help text",

                     EnumValue (TEST_A),

                     MakeEnumAccessor (&AttributeObjectTest::m_enum),

                     MakeEnumChecker (TEST_A, "TestA",

                                      TEST_B, "TestB",

                                      TEST_C, "TestC"))

      .AddAttribute ("TestRandom", "help text",

                     StringValue ("ns3::ConstantRandomVariable[Constant=1.0]"),

                     MakePointerAccessor (&AttributeObjectTest::m_random),

                     MakePointerChecker <RandomVariableStream>())

      .AddAttribute ("TestFloat", "help text",

                     DoubleValue (-1.1),

                     MakeDoubleAccessor (&AttributeObjectTest::m_float),

                     MakeDoubleChecker<float> ())

      .AddAttribute ("TestVector1", "help text",

                     ObjectVectorValue (),

                     MakeObjectVectorAccessor (&AttributeObjectTest::m_vector1),

                     MakeObjectVectorChecker<Derived> ())

      .AddAttribute ("TestVector2", "help text",

                     ObjectVectorValue (),

                     MakeObjectVectorAccessor (&AttributeObjectTest::DoGetVectorN,

                                               &AttributeObjectTest::DoGetVector),

                     MakeObjectVectorChecker<Derived> ())

      .AddAttribute ("TestMap1", "help text",

                     ObjectMapValue (),

                     MakeObjectMapAccessor (&AttributeObjectTest::m_map1),

                     MakeObjectMapChecker<Derived> ())

      .AddAttribute ("IntegerTraceSource1", "help text",

                     IntegerValue (-2),

                     MakeIntegerAccessor (&AttributeObjectTest::m_intSrc1),

                     MakeIntegerChecker<int8_t> ())

      .AddAttribute ("IntegerTraceSource2", "help text",

                     IntegerValue (-2),

                     MakeIntegerAccessor (&AttributeObjectTest::DoSetIntSrc,

                                          &AttributeObjectTest::DoGetIntSrc),

                     MakeIntegerChecker<int8_t> ())

      .AddAttribute ("UIntegerTraceSource", "help text",

                     UintegerValue (2),

                     MakeUintegerAccessor (&AttributeObjectTest::m_uintSrc),

                     MakeIntegerChecker<uint8_t> ())

      .AddAttribute ("DoubleTraceSource", "help text",

                     DoubleValue (2),

                     MakeDoubleAccessor (&AttributeObjectTest::m_doubleSrc),

                     MakeDoubleChecker<double> ())

      .AddAttribute ("BoolTraceSource", "help text",

                     BooleanValue (false),

                     MakeBooleanAccessor (&AttributeObjectTest::m_boolSrc),

                     MakeBooleanChecker ())

      .AddAttribute ("EnumTraceSource", "help text",

                     EnumValue (false),

                     MakeEnumAccessor (&AttributeObjectTest::m_enumSrc),

                     MakeEnumChecker (TEST_A, "TestA"))

      .AddAttribute ("ValueClassSource", "help text",

                     ValueClassTestValue (ValueClassTest ()),

                     MakeValueClassTestAccessor (&AttributeObjectTest::m_valueSrc),

                     MakeValueClassTestChecker ())

      .AddTraceSource ("Source1", "help test",

      .AddTraceSource ("Source2", "help text",

                       MakeTraceSourceAccessor (&AttributeObjectTest::m_cb))

      .AddTraceSource ("ValueSource", "help text",

      .AddAttribute ("Pointer", "help text",

                     PointerValue (),

                     MakePointerAccessor (&AttributeObjectTest::m_ptr),

                     MakePointerChecker<Derived> ())

      .AddAttribute ("PointerInitialized", "help text",

                     StringValue("ns3::Derived"),

                     MakePointerAccessor (&AttributeObjectTest::m_ptrInitialized),

                     MakePointerChecker<Derived> ())

      .AddAttribute ("PointerInitialized2", "help text",

                     StringValue("ns3::Derived[]"),

                     MakePointerAccessor (&AttributeObjectTest::m_ptrInitialized2),

                     MakePointerChecker<Derived> ())

      .AddAttribute ("Callback", "help text",

                     CallbackValue (),

                     MakeCallbackAccessor (&AttributeObjectTest::m_cbValue),

                     MakeCallbackChecker ())

      .AddAttribute ("TestTimeWithBounds", "help text",

                     TimeValue (Seconds (-2)),

                     MakeTimeAccessor (&AttributeObjectTest::m_timeWithBounds),

                     MakeTimeChecker (Seconds (-5), Seconds (10)))

    ;

    return tid;

  }

  AttributeObjectTest (void)

  {

    NS_UNUSED (m_boolTest);

    NS_UNUSED (m_int16);

    NS_UNUSED (m_int16WithBounds);

    NS_UNUSED (m_uint8);

    NS_UNUSED (m_float);

    NS_UNUSED (m_enum);

  }

  virtual ~AttributeObjectTest (void) {};

  void AddToVector1 (void) { m_vector1.push_back (CreateObject<Derived> ()); }

  void AddToVector2 (void) { m_vector2.push_back (CreateObject<Derived> ()); }

  void AddToMap1 (uint32_t i) { m_map1.insert (std::pair <uint32_t, Ptr<Derived> > (i, CreateObject<Derived> ())); }

  void InvokeCb (double a, int b, float c) { m_cb (a,b,c); }

  void InvokeCbValue (int8_t a)

  {

    if (!m_cbValue.IsNull ()) {

        m_cbValue (a);

      }

  }

private:

  void DoSetTestB (bool v) { m_boolTestA = v; }

  bool DoGetTestB (void) const { return m_boolTestA; }

  int16_t DoGetInt16 (void) const { return m_int16SetGet; }

  void DoSetInt16 (int16_t v) { m_int16SetGet = v; }

  uint32_t DoGetVectorN (void) const { return m_vector2.size (); }

  Ptr<Derived> DoGetVector (uint32_t i) const { return m_vector2[i]; }

  bool DoSetIntSrc (int8_t v) { m_intSrc2 = v; return true; }

  int8_t DoGetIntSrc (void) const { return m_intSrc2; }

  bool m_boolTestA;

  bool m_boolTest;

  int16_t m_int16;

  int16_t m_int16WithBounds;

  int16_t m_int16SetGet;

  uint8_t m_uint8;

  float m_float;

  enum Test_e m_enum;

  Ptr<RandomVariableStream> m_random;

  std::vector<Ptr<Derived> > m_vector1;

  std::vector<Ptr<Derived> > m_vector2;

  std::map <uint32_t, Ptr<Derived> > m_map1;

  Callback<void,int8_t> m_cbValue;

  TracedValue<int8_t> m_intSrc1;

  TracedValue<int8_t> m_intSrc2;

  TracedCallback<double, int, float> m_cb;

  TracedValue<ValueClassTest> m_valueSrc;

  Ptr<Derived> m_ptr;

  Ptr<Derived> m_ptrInitialized;

  Ptr<Derived> m_ptrInitialized2;

  TracedValue<uint8_t> m_uintSrc;

  TracedValue<enum Test_e> m_enumSrc;

  TracedValue<double> m_doubleSrc;

  TracedValue<bool> m_boolSrc;

  Time m_timeWithBounds;

};

NS_OBJECT_ENSURE_REGISTERED (AttributeObjectTest);

// ===========================================================================

// Test case template used for generic Attribute Value types -- used to make 

// sure that Attributes work as expected.

// ===========================================================================

template <typename T>

class AttributeTestCase : public TestCase

{

public:

  AttributeTestCase (std::string description);

  virtual ~AttributeTestCase ();

private:

  virtual void DoRun (void);

  bool CheckGetCodePaths (Ptr<Object> p, std::string attributeName, std::string expectedString, T expectedValue);

};

template <typename T>

AttributeTestCase<T>::AttributeTestCase (std::string description)

  : TestCase (description)

{

}

template <typename T>

AttributeTestCase<T>::~AttributeTestCase ()

{

}

template <typename T> bool

AttributeTestCase<T>::CheckGetCodePaths (

  Ptr<Object> p, 

  std::string attributeName,

  std::string expectedString,

  T expectedValue)

{

  StringValue stringValue;

  T actualValue;

  //

  // Get an Attribute value through its StringValue representation.

  //

  bool ok1 = p->GetAttributeFailSafe (attributeName.c_str (), stringValue);

  bool ok2 = stringValue.Get () == expectedString;

  //

  // Get the existing boolean value through its particular type representation.

  //

  bool ok3 = p->GetAttributeFailSafe (attributeName.c_str (), actualValue);

  bool ok4 = expectedValue.Get () == actualValue.Get ();

  return ok1 && ok2 && ok3 && ok4;

}

// ===========================================================================

// The actual Attribute type test cases are specialized for each Attribute type

// ===========================================================================

template <> void

AttributeTestCase<BooleanValue>::DoRun (void)

{

  Ptr<AttributeObjectTest> p;

  bool ok;

  p = CreateObject<AttributeObjectTest> ();

  NS_TEST_ASSERT_MSG_NE (p, 0, "Unable to CreateObject");

  //

  // Set the default value of the BooleanValue and create an object.  The new

  // default value should stick.

  //

  Config::SetDefault ("ns3::AttributeObjectTest::TestBoolName", StringValue ("true"));

  p = CreateObject<AttributeObjectTest> ();

  NS_TEST_ASSERT_MSG_NE (p, 0, "Unable to CreateObject");

  ok = CheckGetCodePaths (p, "TestBoolName", "true", BooleanValue (true));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Attribute not set properly by default value");

  //

  // Set the default value of the BooleanValue the other way and create an object.

  // The new default value should stick.

  //

  Config::SetDefaultFailSafe ("ns3::AttributeObjectTest::TestBoolName", StringValue ("false"));

  p = CreateObject<AttributeObjectTest> ();

  NS_TEST_ASSERT_MSG_NE (p, 0, "Unable to CreateObject");

  ok = CheckGetCodePaths (p, "TestBoolName", "false", BooleanValue (false));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Attribute not et properly by default value");

  //

  // Set the BooleanValue Attribute to true via SetAttributeFailSafe path.

  //

  ok = p->SetAttributeFailSafe ("TestBoolName", StringValue ("true"));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Could not SetAttributeFailSafe() \"TestBoolName\" to true");

  ok = CheckGetCodePaths (p, "TestBoolName", "true", BooleanValue (true));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Attribute not set properly by SetAttributeFailSafe() via StringValue");

  //

  // Set the BooleanValue to false via SetAttributeFailSafe path.

  //

  ok = p->SetAttributeFailSafe ("TestBoolName", StringValue ("false"));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Could not SetAttributeFailSafe() \"TestBoolName\" to false");

  ok = CheckGetCodePaths (p, "TestBoolName", "false", BooleanValue (false));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Attribute not set properly by SetAttributeFailSafe() via StringValue");

  //

  // Create an object using

  //

  p = CreateObject<AttributeObjectTest> ();

  NS_TEST_ASSERT_MSG_NE (p, 0, "Unable to CreateObject");

  //

  // The previous object-based tests checked access directly.  Now check through

  // setter and getter.  The code here looks the same, but the underlying

  // attribute is declared differently in the object.  First make sure we can set

  // to true.

  //

  ok = p->SetAttributeFailSafe ("TestBoolA", StringValue ("true"));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Could not SetAttributeFailSafe() a boolean value to true");

  ok = CheckGetCodePaths (p, "TestBoolA", "true", BooleanValue (true));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Attribute not set properly by SetAttributeFailSafe() (getter/setter) via StringValue");

  //

  // Now Set the BooleanValue to false via the setter.

  //

  ok = p->SetAttributeFailSafe ("TestBoolA", StringValue ("false"));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Could not SetAttributeFailSafe() a boolean value to false");

  ok = CheckGetCodePaths (p, "TestBoolA", "false", BooleanValue (false));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Attribute not set properly by SetAttributeFailSafe() (getter/setter) via StringValue");

}

template <> void

AttributeTestCase<IntegerValue>::DoRun (void)

{

  Ptr<AttributeObjectTest> p;

  bool ok;

  p = CreateObject<AttributeObjectTest> ();

  NS_TEST_ASSERT_MSG_NE (p, 0, "Unable to CreateObject");

  //

  // When the object is first created, the Attribute should have the default 

  // value.

  //

  ok = CheckGetCodePaths (p, "TestInt16", "-2", IntegerValue (-2));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Attribute not set properly by default value");

  //

  // Set the Attribute to a negative value through a StringValue.

  //

  ok = p->SetAttributeFailSafe ("TestInt16", StringValue ("-5"));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Could not SetAttributeFailSafe() via StringValue to -5");

  ok = CheckGetCodePaths (p, "TestInt16", "-5", IntegerValue (-5));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Attribute not set properly by SetAttributeFailSafe() via StringValue");

  //

  // Set the Attribute to a positive value through a StringValue.

  //

  ok = p->SetAttributeFailSafe ("TestInt16", StringValue ("+2"));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Could not SetAttributeFailSafe() via StringValue to +2");

  ok = CheckGetCodePaths (p, "TestInt16", "2", IntegerValue (2));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Attribute not set properly by SetAttributeFailSafe() via StringValue");

  //

  // Set the Attribute to the most negative value of the signed 16-bit range.

  //

  ok = p->SetAttributeFailSafe ("TestInt16", StringValue ("-32768"));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Could not SetAttributeFailSafe() via StringValue to -32768");

  ok = CheckGetCodePaths (p, "TestInt16", "-32768", IntegerValue (-32768));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Attribute not set properly by SetAttributeFailSafe() (most negative) via StringValue");

  //

  // Try to set the Attribute past the most negative value of the signed 16-bit

  // range and make sure the underlying attribute is unchanged.

  //

  ok = p->SetAttributeFailSafe ("TestInt16", StringValue ("-32769"));

  NS_TEST_ASSERT_MSG_EQ (ok, false, "Unexpectedly could SetAttributeFailSafe() via StringValue to -32769");

  ok = CheckGetCodePaths (p, "TestInt16", "-32768", IntegerValue (-32768));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Error in SetAttributeFailSafe() but value changes");

  //

  // Set the Attribute to the most positive value of the signed 16-bit range.

  //

  ok = p->SetAttributeFailSafe ("TestInt16", StringValue ("32767"));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Could not SetAttributeFailSafe() via StringValue to 32767");

  ok = CheckGetCodePaths (p, "TestInt16", "32767", IntegerValue (32767));

  NS_TEST_ASSERT_MSG_EQ (ok, true, "Attribute not set properly by SetAttributeFailSafe() (most positive) via StringValue");

  //

  // Try to set the Attribute past the most positive value of the signed 16-bit

  // range and make sure the underlying attribute is unchanged.

  //

  ok = p->SetAttributeFailSafe ("TestInt16", StringValue ("32768"));

  NS_TEST_ASSERT_MSG_EQ (ok, false, "Unexpectedly could SetAttributeFailSafe() via StringValue to 32768");

  ok = CheckGetCodePaths (p, "TestInt16", "32767", IntegerValue (32767));