length-test-suite.cc

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Lawrence Livermore National Laboratory
 *
 * 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
 *
 * Authors: Mathew Bielejeski<bielejeski1@llnl.gov>
 */
 
#include "ns3/length.h"
#include "ns3/log.h"
#include "ns3/object.h"
#include "ns3/string.h"
#include "ns3/test.h"
 
#ifdef HAVE_BOOST
#include <boost/units/base_units/us/foot.hpp>
#include <boost/units/systems/si.hpp>
#include <boost/units/systems/si/prefixes.hpp>
#endif
 
#include <array>
#include <cmath>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <limits>
#include <map>
#include <sstream>
#include <string>
 
using namespace ns3;
 
using Unit = Length::Unit;
 
class LengthTestCase : public TestCase
{
  public:
    LengthTestCase()
        : TestCase("length-tests")
    {
    }
 
    ~LengthTestCase() override = default;
 
  protected:
    void AssertFalse(bool condition, std::string msg)
    {
        NS_TEST_ASSERT_MSG_EQ(condition, false, msg);
    }
 
    void AssertTrue(bool condition, std::string msg)
    {
        NS_TEST_ASSERT_MSG_EQ(condition, true, msg);
    }
 
  private:
    void TestDefaultLengthIsZero();
 
    void TestConstructLengthFromQuantity();
 
    void TestConstructLengthFromSIUnits();
 
    void TestConstructLengthFromUSUnits();
 
    void TestLengthCopyConstructor();
 
    void TestLengthMoveConstructor();
 
    void TestConstructLengthFromString(double unitValue,
                                       double meterValue,
                                       double tolerance,
                                       const std::initializer_list<std::string>& symbols);
 
    void TestConstructLengthFromMeterString();
    void TestConstructLengthFromNanoMeterString();
    void TestConstructLengthFromMicroMeterString();
    void TestConstructLengthFromMilliMeterString();
    void TestConstructLengthFromCentiMeterString();
    void TestConstructLengthFromKiloMeterString();
    void TestConstructLengthFromNauticalMileString();
    void TestConstructLengthFromInchString();
    void TestConstructLengthFromFootString();
    void TestConstructLengthFromYardString();
    void TestConstructLengthFromMileString();
#ifdef HAVE_BOOST_UNITS
    void TestConstructLengthFromBoostUnits();
    void TestConstructLengthFromBoostUnitsMeters();
    void TestConstructLengthFromBoostUnitsKiloMeters();
    void TestConstructLengthFromBoostUnitsFeet();
#endif
 
    void TestBuilderFreeFunctions();
    void TestTryParseReturnsFalse();
 
    void TestTryParseReturnsTrue();
 
    void TestCopyAssignment();
 
    void TestMoveAssignment();
 
    void TestQuantityAssignment();
 
    void TestIsEqualReturnsTrue();
    void TestIsEqualReturnsFalse();
    void TestIsEqualWithToleranceReturnsTrue();
    void TestIsEqualWithToleranceReturnsFalse();
    void TestIsNotEqualReturnsTrue();
    void TestIsNotEqualReturnsFalse();
    void TestIsNotEqualWithToleranceReturnsTrue();
    void TestIsNotEqualWithToleranceReturnsFalse();
    void TestIsLessReturnsTrue();
    void TestIsLessReturnsFalse();
    void TestIsLessWithToleranceReturnsFalse();
    void TestIsGreaterReturnsTrue();
    void TestIsGreaterReturnsFalse();
    void TestIsGreaterWithToleranceReturnsFalse();
    void TestOutputStreamOperator();
 
    void TestInputStreamOperator();
 
    template <class T>
    void TestLengthSerialization(const Length& l,
                                 const T& unit,
                                 const std::string& expectedOutput,
                                 const std::string& context);
 
    void TestSerializeLengthWithUnit();
 
    void TestOperatorEqualsReturnsTrue();
    void TestOperatorEqualsReturnsFalse();
    void TestOperatorNotEqualsReturnsTrue();
    void TestOperatorNotEqualsReturnsFalse();
    void TestOperatorLessThanReturnsTrue();
    void TestOperatorLessThanReturnsFalse();
    void TestOperatorLessOrEqualReturnsTrue();
    void TestOperatorLessOrEqualReturnsFalse();
    void TestOperatorGreaterThanReturnsTrue();
    void TestOperatorGreaterThanReturnsFalse();
    void TestOperatorGreaterOrEqualReturnsTrue();
    void TestOperatorGreaterOrEqualReturnsFalse();
    void TestAddingTwoLengths();
    void TestAddingLengthAndQuantity();
    void TestAddingQuantityAndLength();
    void TestSubtractingTwoLengths();
    void TestSubtractingLengthAndQuantity();
    void TestSubtractingQuantityAndLength();
    void TestMultiplyLengthByScalar();
    void TestMultiplyScalarByLength();
    void TestDivideLengthByScalar();
    void TestDivideLengthByLength();
    void TestDivideLengthByLengthReturnsNaN();
    void TestDivReturnsCorrectResult();
    void TestDivReturnsZeroRemainder();
    void TestDivReturnsCorrectRemainder();
    void TestModReturnsZero();
    void TestModReturnsNonZero();
    void DoRun() override;
};
 
void
LengthTestCase::TestDefaultLengthIsZero()
{
    Length l;
 
    NS_TEST_ASSERT_MSG_EQ(l.GetDouble(), 0, "Default value of Length is not 0");
}
 
void
LengthTestCase::TestConstructLengthFromQuantity()
{
    const Length::Quantity VALUE(5.0, Unit::Meter);
 
    Length l(VALUE);
 
    NS_TEST_ASSERT_MSG_EQ(l.GetDouble(),
                          VALUE.Value(),
                          "length constructed from meters has wrong value");
}
 
void
LengthTestCase::TestConstructLengthFromSIUnits()
{
    using TestEntry = std::tuple<Length, std::string>;
 
    const double expectedMeters = 1;
    const std::initializer_list<TestEntry> inputs{
        std::make_tuple(Length(1e9, Unit::Nanometer), "nanometer"),
        std::make_tuple(Length(1e6, Unit::Micrometer), "micrometer"),
        std::make_tuple(Length(1e3, Unit::Millimeter), "millimeter"),
        std::make_tuple(Length(1e2, Unit::Centimeter), "centimeter"),
        std::make_tuple(Length(1e-3, Unit::Kilometer), "kilometer"),
        std::make_tuple(Length((1 / 1852.0), Unit::NauticalMile), "nautical_mile")};
 
    for (const TestEntry& entry : inputs)
    {
        const Length& l = std::get<0>(entry);
        const std::string& context = std::get<1>(entry);
 
        NS_TEST_ASSERT_MSG_EQ(l.GetDouble(),
                              expectedMeters,
                              context << ": constructed length from SI unit has wrong value");
    }
}
 
void
LengthTestCase::TestConstructLengthFromUSUnits()
{
    using TestEntry = std::tuple<Length, std::string>;
 
    const double expectedMeters = 0.3048;
    const double tolerance = 0.0001;
 
    const std::initializer_list<TestEntry> inputs{
        std::make_tuple(Length(12.0, Unit::Inch), "inch"),
        std::make_tuple(Length(1.0, Unit::Foot), "foot"),
        std::make_tuple(Length((1 / 3.0), Unit::Yard), "yard"),
        std::make_tuple(Length((1 / 5280.0), Unit::Mile), "mile"),
    };
 
    for (const TestEntry& entry : inputs)
    {
        const Length& l = std::get<0>(entry);
        const std::string& context = std::get<1>(entry);
 
        NS_TEST_ASSERT_MSG_EQ_TOL(l.GetDouble(),
                                  expectedMeters,
                                  tolerance,
                                  "constructed length from US unit (" << context
                                                                      << ") has wrong value");
    }
}
 
void
LengthTestCase::TestLengthCopyConstructor()
{
    const double value = 5;
    Length original(value, Unit::Meter);
 
    Length copy(original);
 
    NS_TEST_ASSERT_MSG_EQ(copy.GetDouble(),
                          original.GetDouble(),
                          "copy constructed length has wrong value");
}
 
void
LengthTestCase::TestLengthMoveConstructor()
{
    const double value = 5;
    Length original(value, Unit::Meter);
 
    Length copy(std::move(original));
 
    NS_TEST_ASSERT_MSG_EQ(copy.GetDouble(), value, "move constructed length has wrong value");
}
 
void
LengthTestCase::TestConstructLengthFromString(double unitValue,
                                              double meterValue,
                                              double tolerance,
                                              const std::initializer_list<std::string>& symbols)
{
    const std::array<std::string, 2> SEPARATORS{{"", " "}};
 
    for (const std::string& symbol : symbols)
    {
        for (const std::string& separator : SEPARATORS)
        {
            std::ostringstream stream;
 
            stream << unitValue << separator << symbol;
 
            Length l(stream.str());
 
            std::ostringstream msg;
            msg << "string constructed length has wrong value: '" << stream.str() << "'";
 
            NS_TEST_ASSERT_MSG_EQ_TOL(l.GetDouble(), meterValue, tolerance, msg.str());
        }
    }
}
 
void
LengthTestCase::TestConstructLengthFromMeterString()
{
    const double value = 5;
 
    TestConstructLengthFromString(value, value, 0, {"m", "meter", "meters", "metre", "metres"});
}
 
void
LengthTestCase::TestConstructLengthFromNanoMeterString()
{
    const double value = 5;
    const double expectedValue = 5e-9;
 
    TestConstructLengthFromString(value,
                                  expectedValue,
                                  0,
                                  {"nm", "nanometer", "nanometers", "nanometre", "nanometres"});
}
 
void
LengthTestCase::TestConstructLengthFromMicroMeterString()
{
    const double value = 5;
    const double expectedValue = 5e-6;
    const double tolerance = 1e-7;
 
    TestConstructLengthFromString(value,
                                  expectedValue,
                                  tolerance,
                                  {"um", "micrometer", "micrometers", "micrometre", "micrometres"});
}
 
void
LengthTestCase::TestConstructLengthFromMilliMeterString()
{
    const double value = 5;
    const double expectedValue = 5e-3;
    const double tolerance = 1e-4;
 
    TestConstructLengthFromString(value,
                                  expectedValue,
                                  tolerance,
                                  {"mm", "millimeter", "millimeters", "millimetre", "millimetres"});
}
 
void
LengthTestCase::TestConstructLengthFromCentiMeterString()
{
    const double value = 5;
    const double expectedValue = 5e-2;
    const double tolerance = 1e-3;
 
    TestConstructLengthFromString(value,
                                  expectedValue,
                                  tolerance,
                                  {"cm", "centimeter", "centimeters", "centimetre", "centimetres"});
}
 
void
LengthTestCase::TestConstructLengthFromKiloMeterString()
{
    const double value = 5;
    const double expectedValue = 5e3;
 
    TestConstructLengthFromString(value,
                                  expectedValue,
                                  0,
                                  {"km", "kilometer", "kilometers", "kilometre", "kilometres"});
}
 
void
LengthTestCase::TestConstructLengthFromNauticalMileString()
{
    const double value = 5;
    const double expectedValue = 9260;
 
    TestConstructLengthFromString(value,
                                  expectedValue,
                                  0,
                                  {"nmi", "nautical mile", "nautical miles"});
}
 
void
LengthTestCase::TestConstructLengthFromInchString()
{
    const double value = 5;
    const double expectedValue = 0.127;
    const double tolerance = 1e-4;
 
    TestConstructLengthFromString(value, expectedValue, tolerance, {"in", "inch", "inches"});
}
 
void
LengthTestCase::TestConstructLengthFromFootString()
{
    const double value = 5;
    const double expectedValue = 1.524;
    const double tolerance = 1e-4;
 
    TestConstructLengthFromString(value, expectedValue, tolerance, {"ft", "foot", "feet"});
}
 
void
LengthTestCase::TestConstructLengthFromYardString()
{
    const double value = 5;
    const double expectedValue = 4.572;
    const double tolerance = 1e-4;
 
    TestConstructLengthFromString(value, expectedValue, tolerance, {"yd", "yard", "yards"});
}
 
void
LengthTestCase::TestConstructLengthFromMileString()
{
    const double value = 5;
    const double expectedValue = 8046.72;
    const double tolerance = 1e-3;
 
    TestConstructLengthFromString(value, expectedValue, tolerance, {"mi", "mile", "miles"});
}
 
#ifdef HAVE_BOOST_UNITS
void
LengthTestCase::TestConstructLengthFromBoostUnits()
{
    TestConstructLengthFromBoostUnitsMeters();
    TestConstructLengthFromBoostUnitsKiloMeters();
    TestConstructLengthFromBoostUnitsFeet();
}
 
void
LengthTestCase::TestConstructLengthFromBoostUnitsMeters()
{
    namespace bu = boost::units;
 
    auto meters = 5 * bu::si::meter;
 
    Length l(meters);
 
    NS_TEST_ASSERT_MSG_EQ(l.GetDouble(),
                          meters.value(),
                          "Construction from boost::units meters produced "
                          "incorrect value");
}
 
void
LengthTestCase::TestConstructLengthFromBoostUnitsKiloMeters()
{
    namespace bu = boost::units;
    auto kilometer = bu::si::kilo * bu::si::meter;
 
    const double expectedValue = 5000;
    auto quantity = 5 * kilometer;
 
    Length l(quantity);
 
    NS_TEST_ASSERT_MSG_EQ(l.GetDouble(),
                          expectedValue,
                          "Construction from boost::units kilometers produced "
                          "incorrect value");
}
 
void
LengthTestCase::TestConstructLengthFromBoostUnitsFeet()
{
    namespace bu = boost::units;
 
    bu::us::foot_base_unit::unit_type Foot;
 
    const double expectedValue = 3.048;
    auto feet = 10 * Foot;
 
    Length l(feet);
 
    NS_TEST_ASSERT_MSG_EQ_TOL(l.GetDouble(),
                              expectedValue,
                              0.001,
                              "Construction from boost::units foot produced "
                              "incorrect value");
}
#endif
 
void
LengthTestCase::TestBuilderFreeFunctions()
{
    using Builder = std::function<Length(double)>;
 
    double inputValue = 10;
 
    std::map<Unit, Builder> TESTDATA{
        {Unit::Nanometer, NanoMeters},
        {Unit::Micrometer, MicroMeters},
        {Unit::Millimeter, MilliMeters},
        {Unit::Centimeter, CentiMeters},
        {Unit::Meter, Meters},
        {Unit::Kilometer, KiloMeters},
        {Unit::NauticalMile, NauticalMiles},
        {Unit::Inch, Inches},
        {Unit::Foot, Feet},
        {Unit::Yard, Yards},
        {Unit::Mile, Miles},
    };
 
    for (auto& entry : TESTDATA)
    {
        Length expected(inputValue, entry.first);
 
        Length output = entry.second(inputValue);
 
        NS_TEST_ASSERT_MSG_EQ(output,
                              expected,
                              "The builder free function for "
                                  << entry.first
                                  << " did not create a Length with the correct value");
    }
}
 
void
LengthTestCase::TestTryParseReturnsFalse()
{
    auto l = Length::TryParse(1, "");
 
    AssertFalse(l.has_value(), "TryParse returned true on bad input");
}
 
void
LengthTestCase::TestTryParseReturnsTrue()
{
    using TestInput = std::pair<double, std::string>;
    using TestArgs = std::pair<double, double>;
    std::map<TestInput, TestArgs> tests{
        {{5, "m"}, {5, 0}},
        {{5, " m"}, {5, 0}},
        {{5, "kilometer"}, {5e3, 0}},
        {{5, " kilometer"}, {5e3, 0}},
    };
 
    for (auto& entry : tests)
    {
        TestInput input = entry.first;
        TestArgs args = entry.second;
 
        auto l = Length::TryParse(input.first, input.second);
 
        AssertTrue(l.has_value(), "TryParse returned false when expecting true");
 
        std::stringstream stream;
        stream << "Parsing input (" << input.first << ", " << input.second
               << ") returned the wrong value";
 
        NS_TEST_ASSERT_MSG_EQ_TOL(l->GetDouble(), args.first, args.second, stream.str());
    }
}
 
void
LengthTestCase::TestCopyAssignment()
{
    const double value = 5;
 
    Length original(value, Unit::Meter);
 
    Length copy;
    copy = original;
 
    NS_TEST_ASSERT_MSG_EQ(copy.GetDouble(), original.GetDouble(), "copy assignment failed");
}
 
void
LengthTestCase::TestMoveAssignment()
{
    const double value = 5;
 
    Length original(value, Unit::Meter);
 
    Length copy;
    copy = std::move(original);
 
    NS_TEST_ASSERT_MSG_EQ(copy.GetDouble(), value, "move assignment failed");
}
 
void
LengthTestCase::TestQuantityAssignment()
{
    Length::Quantity input(5, Unit::Kilometer);
 
    Length l;
    Length expected(input);
 
    l = input;
 
    NS_TEST_ASSERT_MSG_EQ(l, expected, "quantity assignment failed");
}
 
void
LengthTestCase::TestIsEqualReturnsTrue()
{
    const double value = 5;
    Length one(value, Unit::Meter);
    Length two(one);
 
    AssertTrue(one.IsEqual(two), "IsEqual returned false for equal lengths");
}
 
void
LengthTestCase::TestIsEqualReturnsFalse()
{
    const double value = 5;
    Length one(value, Unit::Meter);
    Length two(value, Unit::Foot);
 
    AssertFalse(one.IsEqual(two), "IsEqual returned true for unequal lengths");
}
 
void
LengthTestCase::TestIsEqualWithToleranceReturnsTrue()
{
    const double value = 5;
    const double tolerance = 0.1;
 
    Length one(value, Unit::Meter);
    Length two((value + 0.1), Unit::Meter);
 
    AssertTrue(one.IsEqual(two, tolerance), "IsEqual returned false for almost equal lengths");
}
 
void
LengthTestCase::TestIsEqualWithToleranceReturnsFalse()
{
    const double value = 5;
    const double tolerance = 0.01;
 
    Length one(value, Unit::Meter);
    Length two((value + 0.1), Unit::Meter);
 
    AssertFalse(one.IsEqual(two, tolerance), "IsEqual returned true for almost equal lengths");
}
 
void
LengthTestCase::TestIsNotEqualReturnsTrue()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two((value + 0.1), Unit::Meter);
 
    AssertTrue(one.IsNotEqual(two), "IsNotEqual returned false for not equal lengths");
}
 
void
LengthTestCase::TestIsNotEqualReturnsFalse()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two(one);
 
    AssertFalse(one.IsNotEqual(two), "IsNotEqual returned true for equal lengths");
}
 
void
LengthTestCase::TestIsNotEqualWithToleranceReturnsTrue()
{
    const double tolerance = 0.001;
 
    Length one(5.01, Unit::Meter);
    Length two(5.02, Unit::Meter);
 
    AssertTrue(one.IsNotEqual(two, tolerance),
               "IsNotEqual with tolerance returned false for not equal lengths");
}
 
void
LengthTestCase::TestIsNotEqualWithToleranceReturnsFalse()
{
    const double tolerance = 0.01;
 
    Length one(5.01, Unit::Meter);
    Length two(5.02, Unit::Meter);
 
    AssertFalse(one.IsNotEqual(two, tolerance),
                "IsNotEqual with tolerance returned true for not equal lengths");
}
 
void
LengthTestCase::TestIsLessReturnsTrue()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two((value + 0.1), Unit::Meter);
 
    AssertTrue(one.IsLess(two), "IsLess returned false for non equal lengths");
}
 
void
LengthTestCase::TestIsLessReturnsFalse()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two(one);
 
    AssertFalse(one.IsLess(two), "IsLess returned true for equal lengths");
}
 
void
LengthTestCase::TestIsLessWithToleranceReturnsFalse()
{
    const double tolerance = 0.01;
 
    Length one(5.1234, Unit::Meter);
    Length two(5.1278, Unit::Meter);
 
    AssertFalse(one.IsLess(two, tolerance), "IsLess with tolerance returned true");
}
 
void
LengthTestCase::TestIsGreaterReturnsTrue()
{
    Length one(2.0, Unit::Meter);
    Length two(1.0, Unit::Meter);
 
    AssertTrue(one.IsGreater(two), "IsGreater returned false");
}
 
void
LengthTestCase::TestIsGreaterReturnsFalse()
{
    Length one(2.0, Unit::Meter);
    Length two(1.0, Unit::Meter);
 
    AssertFalse(two.IsGreater(one), "IsGreater returned true");
}
 
void
LengthTestCase::TestIsGreaterWithToleranceReturnsFalse()
{
    const double tolerance = 0.01;
 
    Length one(5.1234, Unit::Meter);
    Length two(5.1278, Unit::Meter);
 
    AssertFalse(two.IsGreater(one, tolerance), "IsGreater returned true");
}
 
void
LengthTestCase::TestOutputStreamOperator()
{
    Length l(1.0, Unit::Meter);
 
    std::stringstream stream;
 
    stream << l;
 
    NS_TEST_ASSERT_MSG_EQ(stream.str(), "1 m", "unexpected output from operator<<");
}
 
void
LengthTestCase::TestInputStreamOperator()
{
    const double value = 5;
 
    Length l;
 
    std::stringstream stream;
 
    stream << value << "m";
 
    stream >> l;
 
    NS_TEST_ASSERT_MSG_EQ(l.GetDouble(), value, "unexpected length from operator>>");
}
 
template <class T>
void
LengthTestCase::TestLengthSerialization(const Length& l,
                                        const T& unit,
                                        const std::string& expectedOutput,
                                        const std::string& context)
{
    const std::string msg = context + ": unexpected output when serializing length";
 
    std::ostringstream stream;
 
    stream << std::fixed << std::setprecision(5) << l.As(unit);
 
    NS_TEST_ASSERT_MSG_EQ(stream.str(), expectedOutput, msg);
}
 
void
LengthTestCase::TestSerializeLengthWithUnit()
{
    Length l(1.0, Unit::Meter);
 
    TestLengthSerialization(l, Unit::Nanometer, "1000000000.00000 nm", "nanometers");
    TestLengthSerialization(l, Unit::Micrometer, "1000000.00000 um", "micrometers");
    TestLengthSerialization(l, Unit::Millimeter, "1000.00000 mm", "millimeters");
    TestLengthSerialization(l, Unit::Centimeter, "100.00000 cm", "centimeters");
    TestLengthSerialization(l, Unit::Meter, "1.00000 m", "meters");
    TestLengthSerialization(l, Unit::Kilometer, "0.00100 km", "kilometers");
    TestLengthSerialization(l, Unit::NauticalMile, "0.00054 nmi", "nautical_mile");
    TestLengthSerialization(l, Unit::Inch, "39.37008 in", "inches");
    TestLengthSerialization(l, Unit::Foot, "3.28084 ft", "feet");
    TestLengthSerialization(l, Unit::Yard, "1.09361 yd", "yards");
    TestLengthSerialization(l, Unit::Mile, "0.00062 mi", "miles");
}
 
void
LengthTestCase::TestOperatorEqualsReturnsTrue()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two(value, Unit::Meter);
 
    AssertTrue(one == two, "operator== returned false for equal lengths");
}
 
void
LengthTestCase::TestOperatorEqualsReturnsFalse()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two(value, Unit::Kilometer);
 
    AssertFalse(one == two, "operator== returned true for non equal lengths");
}
 
void
LengthTestCase::TestOperatorNotEqualsReturnsTrue()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two(value, Unit::Kilometer);
 
    AssertTrue(one != two, "operator!= returned false for non equal lengths");
}
 
void
LengthTestCase::TestOperatorNotEqualsReturnsFalse()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two(value, Unit::Meter);
 
    AssertFalse(one != two, "operator!= returned true for equal lengths");
}
 
void
LengthTestCase::TestOperatorLessThanReturnsTrue()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two(value, Unit::Kilometer);
 
    AssertTrue(one < two, "operator< returned false for smaller length");
}
 
void
LengthTestCase::TestOperatorLessThanReturnsFalse()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two(value, Unit::Kilometer);
 
    AssertFalse(two < one, "operator< returned true for larger length");
}
 
void
LengthTestCase::TestOperatorLessOrEqualReturnsTrue()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two(value, Unit::Kilometer);
    Length three(one);
 
    AssertTrue(one <= two, "operator<= returned false for smaller length");
 
    AssertTrue(one <= three, "operator<= returned false for equal lengths");
}
 
void
LengthTestCase::TestOperatorLessOrEqualReturnsFalse()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two(value, Unit::Kilometer);
 
    AssertFalse(two <= one, "operator<= returned true for larger length");
}
 
void
LengthTestCase::TestOperatorGreaterThanReturnsTrue()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two(value, Unit::Kilometer);
 
    AssertTrue(two > one, "operator> returned false for larger length");
}
 
void
LengthTestCase::TestOperatorGreaterThanReturnsFalse()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two(value, Unit::Kilometer);
 
    AssertFalse(one > two, "operator> returned true for smaller length");
}
 
void
LengthTestCase::TestOperatorGreaterOrEqualReturnsTrue()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two(value, Unit::Kilometer);
    Length three(one);
 
    AssertTrue(two >= one, "operator>= returned false for larger length");
 
    AssertTrue(one >= three, "operator>= returned false for equal lengths");
}
 
void
LengthTestCase::TestOperatorGreaterOrEqualReturnsFalse()
{
    const double value = 5;
 
    Length one(value, Unit::Meter);
    Length two(value, Unit::Kilometer);
 
    AssertFalse(one >= two, "operator>= returned true for smaller length");
}
 
void
LengthTestCase::TestAddingTwoLengths()
{
    const double value = 1;
    const double expectedOutput = 2;
 
    Length one(value, Unit::Meter);
    Length two(value, Unit::Meter);
 
    Length result = one + two;
 
    NS_TEST_ASSERT_MSG_EQ(one.GetDouble(), value, "operator+ modified first operand");
    NS_TEST_ASSERT_MSG_EQ(two.GetDouble(), value, "operator+ modified second operand");
    NS_TEST_ASSERT_MSG_EQ(result.GetDouble(), expectedOutput, "operator+ returned incorrect value");
}
 
void
LengthTestCase::TestAddingLengthAndQuantity()
{
    const double value = 1;
    const double expectedOutput = 2;
 
    Length one(value, Unit::Meter);
 
    Length result = one + Length::Quantity(value, Unit::Meter);
 
    NS_TEST_ASSERT_MSG_EQ(one.GetDouble(), value, "operator+ modified first operand");
    NS_TEST_ASSERT_MSG_EQ(result.GetDouble(), expectedOutput, "operator+ returned incorrect value");
}
 
void
LengthTestCase::TestAddingQuantityAndLength()
{
    const double value = 1;
    const double expectedOutput = 2;
 
    Length one(value, Unit::Meter);
 
    Length result = Length::Quantity(value, Unit::Meter) + one;
 
    NS_TEST_ASSERT_MSG_EQ(one.GetDouble(), value, "operator+ modified first operand");
    NS_TEST_ASSERT_MSG_EQ(result.GetDouble(), expectedOutput, "operator+ returned incorrect value");
}
 
void
LengthTestCase::TestSubtractingTwoLengths()
{
    const double value = 1;
    const double expectedOutput = 0;
 
    Length one(value, Unit::Meter);
    Length two(value, Unit::Meter);
 
    Length result = one - two;
 
    NS_TEST_ASSERT_MSG_EQ(one.GetDouble(), value, "operator- modified first operand");
    NS_TEST_ASSERT_MSG_EQ(two.GetDouble(), value, "operator- modified second operand");
    NS_TEST_ASSERT_MSG_EQ(result.GetDouble(), expectedOutput, "operator- returned incorrect value");
}
 
void
LengthTestCase::TestSubtractingLengthAndQuantity()
{
    const double value = 1;
    const double expectedOutput = 0;
 
    Length one(value, Unit::Meter);
 
    Length result = one - Length::Quantity(value, Unit::Meter);
 
    NS_TEST_ASSERT_MSG_EQ(one.GetDouble(), value, "operator- modified first operand");
    NS_TEST_ASSERT_MSG_EQ(result.GetDouble(), expectedOutput, "operator- returned incorrect value");
}
 
void
LengthTestCase::TestSubtractingQuantityAndLength()
{
    const double value = 1;
    const double expectedOutput = 0;
 
    Length one(value, Unit::Meter);
 
    Length result = Length::Quantity(value, Unit::Meter) - one;
 
    NS_TEST_ASSERT_MSG_EQ(one.GetDouble(), value, "operator- modified second operand");
    NS_TEST_ASSERT_MSG_EQ(result.GetDouble(), expectedOutput, "operator- returned incorrect value");
}
 
void
LengthTestCase::TestMultiplyLengthByScalar()
{
    const double value = 1;
    const double scalar = 5;
    const double expectedOutput = value * scalar;
 
    Length one(value, Unit::Meter);
    Length result = one * scalar;
 
    NS_TEST_ASSERT_MSG_EQ(one.GetDouble(), value, "operator* modified first operand");
    NS_TEST_ASSERT_MSG_EQ(result.GetDouble(), expectedOutput, "operator* returned incorrect value");
}
 
void
LengthTestCase::TestMultiplyScalarByLength()
{
    const double value = 1;
    const double scalar = 5;
    const double expectedOutput = value * scalar;
 
    Length one(value, Unit::Meter);
    Length result = scalar * one;
 
    NS_TEST_ASSERT_MSG_EQ(one.GetDouble(), value, "operator* modified second operand");
    NS_TEST_ASSERT_MSG_EQ(result.GetDouble(), expectedOutput, "operator* returned incorrect value");
}
 
void
LengthTestCase::TestDivideLengthByScalar()
{
    const double value = 10;
    const double scalar = 5;
    const double expectedOutput = value / scalar;
 
    Length one(value, Unit::Meter);
    Length result = one / scalar;
 
    NS_TEST_ASSERT_MSG_EQ(one.GetDouble(), value, "operator/ modified first operand");
    NS_TEST_ASSERT_MSG_EQ(result.GetDouble(), expectedOutput, "operator/ returned incorrect value");
}
 
void
LengthTestCase::TestDivideLengthByLength()
{
    const double valueOne = 100;
    const double valueTwo = 2;
    const double expectedOutput = valueOne / valueTwo;
 
    Length one(valueOne, Unit::Meter);
    Length two(valueTwo, Unit::Meter);
 
    double result = one / two;
 
    NS_TEST_ASSERT_MSG_EQ(one.GetDouble(), valueOne, "operator/ modified first operand");
    NS_TEST_ASSERT_MSG_EQ(two.GetDouble(), valueTwo, "operator/ modified second operand");
    NS_TEST_ASSERT_MSG_EQ(result, expectedOutput, "operator/ returned incorrect value");
}
 
void
LengthTestCase::TestDivideLengthByLengthReturnsNaN()
{
    const double value = 1;
 
    Length one(value, Unit::Meter);
    Length two;
 
    double result = one / two;
 
    AssertTrue(std::isnan(result), "operator/ did not return NaN when dividing by zero");
}
 
void
LengthTestCase::TestDivReturnsCorrectResult()
{
    const double topValue = 100;
    const double bottomValue = 20;
    const int64_t expectedOutput = 5;
 
    Length numerator(topValue, Unit::Meter);
    Length denominator(bottomValue, Unit::Meter);
 
    auto result = Div(numerator, denominator);
 
    NS_TEST_ASSERT_MSG_EQ(result, expectedOutput, "Div() returned an incorrect value");
}
 
void
LengthTestCase::TestDivReturnsZeroRemainder()
{
    const double topValue = 100;
    const double bottomValue = 20;
    const int64_t expectedOutput = 5;
    const int64_t expectedRemainder = 0;
 
    Length numerator(topValue, Unit::Meter);
    Length denominator(bottomValue, Unit::Meter);
    Length remainder;
 
    auto result = Div(numerator, denominator, &remainder);
 
    NS_TEST_ASSERT_MSG_EQ(result, expectedOutput, "Div() returned an incorrect value");
    NS_TEST_ASSERT_MSG_EQ(remainder.GetDouble(),
                          expectedRemainder,
                          "Div() returned an incorrect remainder");
}
 
void
LengthTestCase::TestDivReturnsCorrectRemainder()
{
    const double topValue = 110;
    const double bottomValue = 20;
    const int64_t expectedOutput = 5;
    const int64_t expectedRemainder = 10;
 
    Length numerator(topValue, Unit::Meter);
    Length denominator(bottomValue, Unit::Meter);
    Length remainder;
 
    auto result = Div(numerator, denominator, &remainder);
 
    NS_TEST_ASSERT_MSG_EQ(result, expectedOutput, "Div() returned an incorrect value");
    NS_TEST_ASSERT_MSG_EQ(remainder.GetDouble(),
                          expectedRemainder,
                          "Div() returned an incorrect remainder");
}
 
void
LengthTestCase::TestModReturnsZero()
{
    Length numerator(10, Unit::Meter);
    Length denominator(2, Unit::Meter);
 
    auto result = Mod(numerator, denominator);
 
    NS_TEST_ASSERT_MSG_EQ(result.GetDouble(), 0, "Mod() returned a non zero value");
}
 
void
LengthTestCase::TestModReturnsNonZero()
{
    Length numerator(14, Unit::Meter);
    Length denominator(3, Unit::Meter);
    const double expectedValue = 2;
 
    auto result = Mod(numerator, denominator);
 
    NS_TEST_ASSERT_MSG_EQ(result.GetDouble(), expectedValue, "Mod() returned the wrong value");
}
 
void
LengthTestCase::DoRun()
{
    TestDefaultLengthIsZero();
 
    TestConstructLengthFromQuantity();
 
    TestConstructLengthFromSIUnits();
 
    TestConstructLengthFromUSUnits();
 
    TestLengthCopyConstructor();
 
    TestLengthMoveConstructor();
 
    TestConstructLengthFromMeterString();
    TestConstructLengthFromNanoMeterString();
    TestConstructLengthFromMicroMeterString();
    TestConstructLengthFromMilliMeterString();
    TestConstructLengthFromCentiMeterString();
    TestConstructLengthFromKiloMeterString();
    TestConstructLengthFromNauticalMileString();
    TestConstructLengthFromInchString();
    TestConstructLengthFromFootString();
    TestConstructLengthFromYardString();
    TestConstructLengthFromMileString();
 
#ifdef HAVE_BOOST_UNITS
    TestConstructLengthFromBoostUnits();
#endif
 
    TestBuilderFreeFunctions();
 
    TestTryParseReturnsFalse();
    TestTryParseReturnsTrue();
 
    TestCopyAssignment();
    TestMoveAssignment();
    TestQuantityAssignment();
 
    TestIsEqualReturnsTrue();
    TestIsEqualReturnsFalse();
    TestIsEqualWithToleranceReturnsTrue();
    TestIsEqualWithToleranceReturnsFalse();
    TestIsNotEqualReturnsTrue();
    TestIsNotEqualReturnsFalse();
    TestIsNotEqualWithToleranceReturnsTrue();
    TestIsNotEqualWithToleranceReturnsFalse();
    TestIsLessReturnsTrue();
    TestIsLessReturnsFalse();
    TestIsLessWithToleranceReturnsFalse();
    TestIsGreaterReturnsTrue();
    TestIsGreaterReturnsFalse();
    TestIsGreaterWithToleranceReturnsFalse();
 
    TestOutputStreamOperator();
 
    TestSerializeLengthWithUnit();
 
    TestOperatorEqualsReturnsTrue();
    TestOperatorEqualsReturnsFalse();
    TestOperatorNotEqualsReturnsTrue();
    TestOperatorNotEqualsReturnsFalse();
    TestOperatorLessThanReturnsTrue();
    TestOperatorLessThanReturnsFalse();
    TestOperatorLessOrEqualReturnsTrue();
    TestOperatorLessOrEqualReturnsFalse();
    TestOperatorGreaterThanReturnsTrue();
    TestOperatorGreaterThanReturnsFalse();
    TestOperatorGreaterOrEqualReturnsTrue();
    TestOperatorGreaterOrEqualReturnsFalse();
 
    TestAddingTwoLengths();
    TestAddingLengthAndQuantity();
    TestAddingQuantityAndLength();
    TestSubtractingTwoLengths();
    TestSubtractingLengthAndQuantity();
    TestSubtractingQuantityAndLength();
    TestMultiplyLengthByScalar();
    TestMultiplyScalarByLength();
    TestDivideLengthByScalar();
    TestDivideLengthByLength();
    TestDivideLengthByLengthReturnsNaN();
 
    TestDivReturnsCorrectResult();
    TestDivReturnsZeroRemainder();
    TestDivReturnsCorrectRemainder();
 
    TestModReturnsZero();
    TestModReturnsNonZero();
}
 
class LengthValueTestCase : public TestCase
{
  public:
    LengthValueTestCase()
        : TestCase("length-value-tests")
    {
    }
 
    ~LengthValueTestCase() override
    {
    }
 
  private:
    class TestObject : public Object
    {
      public:
        static TypeId GetTypeId();
 
        TestObject()
            : m_length()
        {
        }
 
        ~TestObject() override
        {
        }
 
      private:
        Length m_length; 
    };
 
  private:
    void TestAttributeConstructor();
 
    void TestAttributeSerialization();
 
    void TestAttributeDeserialization();
 
    void TestObjectAttribute();
 
    void TestSetAttributeUsingStringValue();
 
    // Inherited function
    void DoRun() override;
};
 
TypeId
LengthValueTestCase::TestObject::GetTypeId()
{
    static TypeId tid = TypeId("LengthValueTestCase::TestObject")
                            .SetParent<Object>()
                            .SetGroupName("Test")
                            .AddConstructor<TestObject>()
                            .AddAttribute("Length",
                                          "Length value",
                                          LengthValue(),
                                          MakeLengthAccessor(&TestObject::m_length),
                                          MakeLengthChecker());
 
    return tid;
}
 
void
LengthValueTestCase::TestAttributeConstructor()
{
    Length l = KiloMeters(2);
    LengthValue value(l);
 
    NS_TEST_ASSERT_MSG_EQ(value.Get(), l, "Length attribute has wrong value");
}
 
void
LengthValueTestCase::TestAttributeSerialization()
{
    Ptr<const AttributeChecker> checker = MakeLengthChecker();
 
    Length l = KiloMeters(2);
    LengthValue value(l);
 
    std::string output = value.SerializeToString(checker);
 
    NS_TEST_ASSERT_MSG_EQ(output, "2000 m", "Length attribute serialization has wrong output");
}
 
void
LengthValueTestCase::TestAttributeDeserialization()
{
    Ptr<const AttributeChecker> checker = MakeLengthChecker();
 
    Length l = KiloMeters(2);
    std::ostringstream stream;
    stream << l;
 
    LengthValue value;
    bool result = value.DeserializeFromString(stream.str(), checker);
 
    NS_TEST_ASSERT_MSG_EQ(result, true, "Length attribute deserialization failed");
    NS_TEST_ASSERT_MSG_EQ(value.Get(), l, "Length attribute has wrong value after deserialization");
}
 
void
LengthValueTestCase::TestObjectAttribute()
{
    Length expected(5, Unit::Kilometer);
    Ptr<TestObject> obj = CreateObject<TestObject>();
 
    obj->SetAttribute("Length", LengthValue(expected));
 
    LengthValue val;
    obj->GetAttribute("Length", val);
 
    NS_TEST_ASSERT_MSG_EQ(val.Get(), expected, "Length attribute does not have expected value");
}
 
void
LengthValueTestCase::TestSetAttributeUsingStringValue()
{
    Length expected(5, Unit::Kilometer);
    Ptr<TestObject> obj = CreateObject<TestObject>();
 
    std::stringstream stream;
    stream << expected.As(Unit::Kilometer);
 
    obj->SetAttribute("Length", StringValue(stream.str()));
 
    LengthValue val;
    obj->GetAttribute("Length", val);
 
    NS_TEST_ASSERT_MSG_EQ(val.Get(), expected, "Length attribute does not have expected value");
}
 
void
LengthValueTestCase::DoRun()
{
    TestAttributeConstructor();
    TestAttributeSerialization();
    TestAttributeDeserialization();
    TestObjectAttribute();
    TestSetAttributeUsingStringValue();
}
 
class LengthTestSuite : public TestSuite
{
  public:
    LengthTestSuite();
};
 
LengthTestSuite::LengthTestSuite()
    : TestSuite("length")
{
    AddTestCase(new LengthTestCase(), TestCase::QUICK);
    AddTestCase(new LengthValueTestCase(), TestCase::QUICK);
}
 
static LengthTestSuite gLengthTestSuite;