public void Should_compare_with_null_instance(double value)
{
var instance = new Metre(value);
Assert.IsFalse(instance.Equals(null), "Equals");
Assert.AreEqual(1, instance.CompareTo(null), "CompareTo");
}
public void Should_not_throw_exception_on_division_by_zero(double value, double expectedValue)
{
var instance = new Metre(value);
var actual = instance / 0d;
Assert.AreEqual(expectedValue, actual.Value);
}
public void Should_initialize_instance(double value)
{
var actual = new Metre(value);
Assert.IsAssignableFrom <Metre>(actual);
Assert.AreEqual(value, actual.Value, nameof(actual.Value));
}
public void Should_compare_with_another_type_of_instance(double value)
{
var instance1 = new Metre(value);
object instance2 = value;
Assert.IsFalse(instance1.Equals(instance2), "Equals");
Assert.Throws <ArgumentException>(() => instance1.CompareTo(instance2), "CompareTo");
}
public void Should_cast_to_double(double value)
{
var instance = new Metre(value);
var actual = (double)instance;
Assert.AreEqual(value, actual);
}
public void Should_cast_from_double(double value)
{
var expected = new Metre(value);
var actual = (Metre)value;
Assert.AreEqual(expected, actual);
}
public void DictionaryTest()
{
Unit millimetre = new Metre()
{
UnitPrefix = MetricPrefix.Milli
};
Unit centimetre = new Metre()
{
UnitPrefix = MetricPrefix.Centi
};
Unit decimetre = new Metre()
{
UnitPrefix = MetricPrefix.Deci
};
Unit inch = new Inch();
Dictionary <Unit, string> units = new Dictionary <Unit, string>();
units.Add(millimetre, millimetre.Symbol);
units.Add(centimetre, centimetre.Symbol);
units.Add(decimetre, decimetre.Symbol);
units.Add(inch, inch.Symbol);
//Theese should work, of course
Assert.IsTrue(units.ContainsKey(millimetre));
Assert.IsTrue(units.ContainsKey(centimetre));
Assert.IsTrue(units.ContainsKey(decimetre));
Assert.IsTrue(units.ContainsKey(inch));
Unit newMillimetre = new Metre()
{
UnitPrefix = MetricPrefix.Milli
};
Unit newInch = new Inch();
//Why this does not work? After all, isn't a millimetre always a millimetre?
Assert.IsTrue(units.ContainsKey(newMillimetre));
Assert.IsTrue(units.ContainsKey(newInch));
bool containsNewMillimetre = false;
bool containsNewInch = false;
foreach (Unit unit in units.Keys)
{
if (unit == newMillimetre)
{
containsNewMillimetre = true;
}
if (unit == newInch)
{
containsNewInch = true;
}
}
Assert.IsTrue(containsNewMillimetre);
Assert.IsTrue(containsNewInch);
Assert.IsTrue(units[newMillimetre] == millimetre.Symbol);
Assert.IsTrue(units[newInch] == inch.Symbol);
}
public void Should_format_string(string format, string mask)
{
var expected = string.Format(Consts.CultureEnUS, mask, 1.757899e2);
var instance = new Metre(1.757899e2);
var actual = instance.ToString(format, Consts.CultureEnUS);
Assert.AreEqual(expected, actual);
}
public void Should_divide_instance_by_double(double leftValue, double rightValue, double expectedValue)
{
var expected = new Metre(expectedValue);
var instance = new Metre(leftValue);
var actual = instance / rightValue;
Assert.AreEqual(expected, actual);
}
public void Should_own_a_HashCode(double value)
{
var expected = value.GetHashCode();
var instance = new Metre(value);
var actual = instance.GetHashCode();
Assert.AreEqual(expected, actual);
}
public void Should_round_value_withDigit(double value, double expectedValue)
{
var expected = new Metre(expectedValue);
var instance = new Metre(value);
var actual = instance.Round(1);
Assert.AreEqual(expected, actual);
}
public void Should_roundvalue_withMode(MidpointRounding mode, double value, double expectedValue)
{
var expected = new Metre(expectedValue);
var instance = new Metre(value);
var actual = instance.Round(mode);
Assert.AreEqual(expected, actual);
}
public void Should_floor_value(double value, double expectedValue)
{
var expected = new Metre(expectedValue);
var instance = new Metre(value);
var actual = instance.Floor();
Assert.AreEqual(expected, actual);
}
public void Should_convert_to_string(double value)
{
var expected = $"{value:e} m";
var instance = new Metre(value);
var actual = instance.ToString();
Assert.AreEqual(expected, actual);
}
public void Should_multiply_double_by_instance(double leftValue, double rightValue, double expectedValue)
{
var expected = new Metre(expectedValue);
var instance = new Metre(rightValue);
var actual = leftValue * instance;
Assert.AreEqual(expected, actual);
}
public void Should_subtract_two_instances(double leftValue, double rightValue, double expectedValue)
{
var expected = new Metre(expectedValue);
var leftInstance = new Metre(leftValue);
var rightInstance = new Metre(rightValue);
var actual = leftInstance - rightInstance;
Assert.AreEqual(expected, actual);
}
public void Should_multiply_squareMetre_by_instance(double leftValue, double rightValue, double expectedValue)
{
var expected = new CubicMetre(expectedValue);
var leftInstance = new SquareMetre(leftValue);
var rightInstance = new Metre(rightValue);
var actual = leftInstance * rightInstance;
Assert.AreEqual(expected, actual);
}
public void ListTest()
{
Unit millimetre = new Metre()
{
UnitPrefix = MetricPrefix.Milli
};
Unit centimetre = new Metre()
{
UnitPrefix = MetricPrefix.Centi
};
Unit decimetre = new Metre()
{
UnitPrefix = MetricPrefix.Deci
};
Unit inch = new Inch();
List <Unit> units = new List <Unit>();
units.Add(millimetre);
units.Add(centimetre);
units.Add(decimetre);
units.Add(inch);
//Theese should work, of course
Assert.IsTrue(units.Contains(millimetre));
Assert.IsTrue(units.Contains(centimetre));
Assert.IsTrue(units.Contains(decimetre));
Assert.IsTrue(units.Contains(inch));
Unit newMillimetre = new Metre()
{
UnitPrefix = MetricPrefix.Milli
};
Unit newInch = new Inch();
//Why this does not work? After all, isn't a millimetre always a millimetre?
Assert.IsTrue(units.Contains(newMillimetre));
Assert.IsTrue(units.Contains(newInch));
bool containsNewMillimetre = false;
bool containsNewInch = false;
foreach (Unit unit in units)
{
if (unit == newMillimetre)
{
containsNewMillimetre = true;
}
if (unit == newInch)
{
containsNewInch = true;
}
}
Assert.IsTrue(containsNewMillimetre);
Assert.IsTrue(containsNewInch);
}
public void PathToDefaultUnitTest()
{
//from pico Gram to default Kilo Gram
Unit target = new Gram();
((MetricUnit)target).UnitPrefix = MetricPrefix.None;
UnitPathStack actual = target.PathToDefaultUnit();
double expected = System.Math.Pow(10, -3);
Assert.AreEqual(expected, actual.ConversionFactor);
target = new Metre();
((MetricUnit)target).UnitPrefix = MetricPrefix.Tera;
actual = target.PathToDefaultUnit();
expected = System.Math.Pow(10, 12);
Assert.AreEqual(expected, actual.ConversionFactor);
target = new Unit(typeof(QuantitySystem.Quantities.Volume <>));
actual = target.PathToDefaultUnit();
expected = 1;
Assert.AreEqual(expected, actual.ConversionFactor);
target = new QuantitySystem.Units.Metric.Litre();
//((SIUnit)target).UnitPrefix = SIPrefix.Kilo;
actual = target.PathToDefaultUnit(); // from Litre to m^3
expected = 1e-3;
Assert.AreEqual(expected, actual.ConversionFactor);
target = new QuantitySystem.Units.Metric.Litre();
((MetricUnit)target).UnitPrefix = MetricPrefix.Kilo;
actual = target.PathToDefaultUnit(); // from Litre to m^3
expected = 1;
Assert.AreEqual(expected, actual.ConversionFactor);
target = new QuantitySystem.Units.Metric.Bar();
//((SIUnit)target).UnitPrefix = SIPrefix.Kilo;
actual = target.PathToDefaultUnit(); // from Litre to m^3
expected = 1e+5;
Assert.AreEqual(expected, actual.ConversionFactor);
target = new QuantitySystem.Units.Metric.Cgs.Dyne();
actual = target.PathToDefaultUnit();
expected = 1e-5;
Assert.AreEqual(expected, actual.ConversionFactor);
}
public void MetreConstructorTest()
{
Metre target = new Metre();
Assert.AreEqual("m", target.Symbol);
Assert.AreEqual(typeof(Length <>), target.QuantityType);
Assert.AreEqual(MetricPrefix.None, target.UnitPrefix);
Assert.AreEqual(true, target.IsBaseUnit);
Assert.AreEqual(true, target.IsDefaultUnit);
}
public void Should_cast_from_Megametre(double megametreValue, double expectedValue)
{
var megametreInstance = new SystemOfUnits.Length.Metre.Megametre(megametreValue);
Metre actual = megametreInstance;
Assert.IsAssignableFrom <Metre>(actual);
var actualValue = actual.Value;
Assert.AreEqual(expectedValue.ToString("E"), actualValue.ToString("E"));
}
public void VelocityEquation()
{
int value1 = 100;
int value2 = 100;
PhysicalUnit second = new Second(value1);
PhysicalUnit metre = new Metre(value2);
Velocity velocity = metre / second;
Assert.AreEqual(expected: value1 / value2, actual: velocity.Value);
}
public void LengthTestPassing()
{
double value1 = 100;
double value2 = 300;
Metre metre1 = new Metre(value1, 100, 600);
Metre metre2 = new Metre(value2);
Kilometre kilometre = metre1 + metre2;
Assert.AreEqual(expected: (value2 + value1) * 1 / Kilometre.KilometreConversionFactor, actual: kilometre.Value);
}
public void MoreEqualityTestsTest()
{
Unit millimetre = new Metre()
{
UnitPrefix = MetricPrefix.Milli
};
Unit centimetre = new Metre()
{
UnitPrefix = MetricPrefix.Centi
};
Unit decimetre = new Metre()
{
UnitPrefix = MetricPrefix.Deci
};
Unit inch = new Inch();
Assert.IsTrue(millimetre != centimetre);
Assert.IsTrue(AreNotEqual(millimetre, centimetre));
}
public void PathFromDefaultUnitTest()
{
MetricUnit target = new Gram();
target.UnitPrefix = MetricPrefix.Milli;
UnitPathStack actual = target.PathFromDefaultUnit();
double expected = System.Math.Pow(10, 6);
Assert.AreEqual(expected, actual.ConversionFactor);
target = new Metre();
target.UnitPrefix = MetricPrefix.Tera;
actual = target.PathFromDefaultUnit();
expected = System.Math.Pow(10, -12);
Assert.AreEqual(expected, actual.ConversionFactor);
}
public void Should_compare_with_same_value(double value)
{
var baseInstance = new Metre(value);
var otherInstance = new Metre(value);
Assert.IsTrue(baseInstance.Equals(otherInstance), "Equals");
Assert.IsTrue(baseInstance.Equals((object)otherInstance), "Equals object");
Assert.IsTrue(baseInstance == otherInstance, "==");
Assert.IsFalse(baseInstance != otherInstance, "!=");
Assert.AreEqual(0, baseInstance.CompareTo(otherInstance), "CompareTo");
Assert.AreEqual(0, baseInstance.CompareTo((object)otherInstance), "CompareTo object");
Assert.IsFalse(baseInstance < otherInstance, "<");
Assert.IsFalse(baseInstance > otherInstance, ">");
Assert.IsTrue(baseInstance <= otherInstance, "<=");
Assert.IsTrue(baseInstance >= otherInstance, ">=");
}
public void Should_compare_with_smaller_value(double baseValue, double smallerValue)
{
var baseInstance = new Metre(baseValue);
var smallerInstance = new Metre(smallerValue);
Assert.IsFalse(baseInstance.Equals(smallerInstance), "Equals");
Assert.IsFalse(baseInstance.Equals((object)smallerInstance), "Equals object");
Assert.IsFalse(baseInstance == smallerInstance, "==");
Assert.IsTrue(baseInstance != smallerInstance, "!=");
Assert.AreEqual(+1, baseInstance.CompareTo(smallerInstance), "CompareTo");
Assert.AreEqual(+1, baseInstance.CompareTo((object)smallerInstance), "CompareTo object");
Assert.IsFalse(baseInstance < smallerInstance, "<");
Assert.IsTrue(baseInstance > smallerInstance, ">");
Assert.IsFalse(baseInstance <= smallerInstance, "<=");
Assert.IsTrue(baseInstance >= smallerInstance, ">=");
}
public void Should_compare_with_bigger_value(double baseValue, double biggerValue)
{
var baseInstance = new Metre(baseValue);
var biggerInstance = new Metre(biggerValue);
Assert.IsFalse(baseInstance.Equals(biggerInstance), "Equals");
Assert.IsFalse(baseInstance.Equals((object)biggerInstance), "Equals object");
Assert.IsFalse(baseInstance == biggerInstance, "==");
Assert.IsTrue(baseInstance != biggerInstance, "!=");
Assert.AreEqual(-1, baseInstance.CompareTo(biggerInstance), "CompareTo");
Assert.AreEqual(-1, baseInstance.CompareTo((object)biggerInstance), "CompareTo object");
Assert.IsTrue(baseInstance < biggerInstance, "<");
Assert.IsFalse(baseInstance > biggerInstance, ">");
Assert.IsTrue(baseInstance <= biggerInstance, "<=");
Assert.IsFalse(baseInstance >= biggerInstance, ">=");
}
public void PathToUnitTest()
{
double expected = 63360;
Mile mil = new Mile();
Inch i = new Inch();
UnitPathStack actual = mil.PathToUnit(i);
Assert.AreEqual(expected, actual.ConversionFactor);
Gram g = new Gram();
g.UnitPrefix = MetricPrefix.None;
Gram Mg = new Gram();
Mg.UnitPrefix = MetricPrefix.Mega;
actual = g.PathToUnit(Mg);
Assert.AreEqual(1e-6, actual.ConversionFactor);
Metre mr = new Metre();
actual = i.PathToUnit(mr);
Assert.AreEqual(0.0254, actual.ConversionFactor);
//now the idea is to make any combination of units to go to any combination of units
QuantityDimension qd = QuantityDimension.ParseMLT("M1L0T-1");
Unit u = Unit.DiscoverUnit(qd);
Assert.AreEqual("<kg/s>", u.Symbol);
Assert.AreEqual(qd, u.UnitDimension);
}
public Metre3 SetMaxVolume(Metre volume)
{
maxVolume = volume;
}