#include "ns3/int64x64.h"

#include "ns3/test.h"

#include <iomanip>

using namespace ns3;

/**

 * \internal

 *

 * Some of these tests are a little unusual for ns-3 in that they

 * To handle this, where needed we define a tolerance to use in the

 * test comparisions.  If you need to increase the tolerance,

 * please append the system and compiler version.  For example:

 *

 * \code

 *   // Darwin 12.5.0 (Mac 10.8.5) g++ 4.2.1

 *   tolerance = 1;

 *   // System Foo gcc 3.9

 *   tolerance = 3;

 * \endcode

 */

class Int64x64HiLoTestCase : public TestCase

{

public:

  Int64x64HiLoTestCase ();

  virtual void DoRun (void);

};

Int64x64HiLoTestCase::Int64x64HiLoTestCase ()

  : TestCase ("Manipulate the high and low part of every number")

{

}

{

  if (int64x64_t::implementation == int64x64_t::ld_impl)

    {

      // Darwin 12.5.0 (Mac 10.8.5) g++ 4.2.1

      tolerance = 1;

    }

  Check (-1, 0);

}

class Int64x64InputTestCase : public TestCase

{

public:

  Int64x64InputTestCase ();

  virtual void DoRun (void);

  void Check (const std::string & str,

	      const int64_t hi, const uint64_t lo,

};

Int64x64InputTestCase::Int64x64InputTestCase ()

  : TestCase ("Parse int64x64_t numbers as strings")

{

}

void 

Int64x64InputTestCase::Check (const std::string & str,

			      const int64_t hi, const uint64_t lo,

{

  std::istringstream iss;

  iss.str (str);

  std::string input = "\"" + str + "\"";

  std::cout << GetParent ()->GetName () << " Input: "

	    << std::left << std::setw (28) << input << std::right

	    << std::endl;

			 "High parts do not match for input string \""

			 << str << "\"");

			     "Low parts do not match for input string \""

			     << str << "\"");

}

void

Int64x64InputTestCase::DoRun (void)

{

  std::cout << std::endl;

	    << std::endl;

  int64_t tolerance = 0;

  if (int64x64_t::implementation == int64x64_t::ld_impl)

    {

      // Darwin 12.5.0 (Mac 10.8.5) g++ 4.2.1

      tolerance = 2;

    }

  Check ("1", 1, 0);

  Check ("+1", 1, 0);

  Check ("-1", -1, 0);

  Check ("1.0", 1, 0);

  Check ("+1.0", 1, 0);

  Check ("001.0", 1, 0);

  Check ("+001.0", 1, 0);

  Check ("020.0", 20, 0);

  Check ("+020.0", 20, 0);

  Check ("1.0000000", 1, 0);

  Check ("-1.0", -1, 0, tolerance);

  Check ("-1.0000", -1, 0, tolerance);

  Check (" 1.000000000000000000054",  1, 1, tolerance);

}

class Int64x64InputOutputTestCase : public TestCase

{

public:

  Int64x64InputOutputTestCase ();

  virtual void DoRun (void);

  void Check (const std::string & str,

	      const int64_t tolerance = 0);

};

Int64x64InputOutputTestCase::Int64x64InputOutputTestCase ()

  : TestCase ("Roundtrip int64x64_t numbers as strings")

{

}

void 

Int64x64InputOutputTestCase::Check (const std::string & str,

				    const int64_t tolerance /* = 0 */)

{

  int64x64_t value;

  std::string input  = "\"" + str + "\"";

  std::string output = "\"" + oss.str () + "\"";

    {

    }

  else

    {

}

void

Int64x64InputOutputTestCase::DoRun (void)

{

  std::cout << std::endl;

	    << std::endl;

  int64_t tolerance = 0;

  if (int64x64_t::implementation == int64x64_t::ld_impl)

    {

      // Darwin 12.5.0 (Mac 10.8.5) g++ 4.2.1

      tolerance = 1;

    }

  Check ("+1.000000000000000000000");

  Check ("+20.000000000000000000000");

  Check ("+0.000000000000000000000", tolerance);

  Check ("-1.000000000000000000000", tolerance);

  Check ("+1.084467440737095516158", tolerance);

  Check ("-2.084467440737095516158", tolerance);

  Check ("+3.184467440737095516179", tolerance);

  Check ("-4.184467440737095516179", tolerance);

}

class Int64x64ArithmeticTestCase : public TestCase

{

public:

  Int64x64ArithmeticTestCase ();

  virtual void DoRun (void);

  void Check (const int        test,

  void Check (const int        test,

	      const int64x64_t tolerance);

};

Int64x64ArithmeticTestCase::Int64x64ArithmeticTestCase ()

  : TestCase ("Basic arithmetic operations")

{

}

void

Int64x64ArithmeticTestCase::Check (const int test,

				   const int64x64_t value,

{

  int64x64_t zero (0,0);

}

void

Int64x64ArithmeticTestCase::Check (const int test,

				   const int64x64_t value,

				   const int64x64_t tolerance)

{

  std::cout << GetParent ()->GetName () << " Arithmetic: "

	    << " (+/- " << tolerance << ")"

	    << std::endl;

			      "Arithmetic failure in test case " << test);

}

void

Int64x64ArithmeticTestCase::DoRun (void)

{

  const int64x64_t zero (0, 0);

  const int64x64_t one  (1, 0);

  const int64x64_t two  (2, 0);

  const int64x64_t thre (3, 0);

  std::cout << std::endl;

	    << std::endl;

  Check ( 0,   zero  -   zero ,   zero  );

  Check ( 1,   zero  -   one ,   -one   );

  Check ( 2,   one   -   one ,    zero  );

  Check ( 3,   one   -   two ,   -one   );

  Check ( 4,   one   - (-one ),   two   );

  Check ( 5, (-one ) - (-two ),   one   );

  Check ( 6, (-one ) -   two ,   -thre  );

  Check ( 7,   zero  +   zero ,   zero  );

  Check ( 8,   zero  +   one ,    one   );

  Check ( 9,   one   +   one ,    two   );

  Check (10,   one   +   two ,    thre  );

  Check (11,   one   + (-one ),   zero  );

  Check (12, (-one ) + (-two ),  -thre  );

  Check (13, (-one ) +   two ,    one   );

  Check (14,   zero  *   zero ,   zero  );

  Check (15,   zero  *   one ,    zero  );

  Check (16,   zero  * (-one ),   zero  );

  Check (17,   one   *   one ,    one   );

  Check (18,   one   * (-one ),  -one   );

  Check (19, (-one ) * (-one ),   one   );

  const int64x64_t frac  = int64x64_t (0, 0xc000000000000000ULL);  // 0.75

  const int64x64_t fplf2 = frac + frac * frac;  // 1.3125

  const int64x64_t zerof = zero + frac;

  const int64x64_t onef  = one  + frac;

  const int64x64_t twof  = two  + frac;

  const int64x64_t thref = thre + frac;

  // Multiplication followed by division is exact:

  // Division followed by multiplication loses a bit or two:

  // The example below shows that we really do not lose

  // much precision internally: it is almost always the

  // final conversion which loses precision.

	      int64x64_t (1999999999, 0xfffffffffffffffeULL));

  // Check special values

	           int64x64_t (0, 0xd83c94fb6d2ac34aULL));

}

/**

 * See \bugid{455}

 */

class Int64x64Bug455TestCase : public TestCase

{

public:

  Int64x64Bug455TestCase ();

  virtual void DoRun (void);

  void Check (const double result, const double expect,

	      const std::string & msg);

};

Int64x64Bug455TestCase::Int64x64Bug455TestCase ()

  : TestCase ("Test case for bug 455")

{

}

void

Int64x64Bug455TestCase::Check (const double result, const double expect,

			       const std::string & msg)

{

  std::cout << GetParent ()->GetName () << " Bug 455: "

	    << "res: "  << result

	    << " exp: " << expect

	    << ": " << msg

	    << std::endl;

  NS_TEST_ASSERT_MSG_EQ (result, expect, msg);

}

void

Int64x64Bug455TestCase::DoRun (void)

{

  std::cout << std::endl;

	    << std::endl;

  int64x64_t a = int64x64_t (0.1);

  a /= int64x64_t (1.25);

  Check (a.GetDouble (), 0.08, "The original testcase");