public void VerifyAllEnums()
{
var acceleration = new Acceleration(1, AccelerationUnit.BaseUnit);
var angle = new Angle(1, AngleUnit.BaseUnit);
var angularAcceleration = new AngularAcceleration(1, AngularAccelerationUnit.BaseUnit);
var area = new Area(1, AreaUnit.BaseUnit);
var density = new MassDensity(1, MassDensityUnit.BaseUnit);
var electricCurrent = new ElectricCurrent(1, ElectricCurrentUnit.BaseUnit);
var electricResistance = new ElectricResistance(1, ElectricResistanceUnit.BaseUnit);
var electricVoltage = new ElectricPotential(1, ElectricPotentialUnit.BaseUnit);
var energy = new Energy(1, EnergyUnit.BaseUnit);
var force = new Force(1, ForceUnit.BaseUnit);
var frequency = new Frequency(1, FrequencyUnit.BaseUnit);
var jerk = new Jerk(1, JerkUnit.BaseUnit);
var length = new Length(1, LengthUnit.BaseUnit);
var mass = new Mass(1, MassUnit.BaseUnit);
var massFlowRate = new MassFlowRate(1, MassFlowRateUnit.BaseUnit);
var momentum = new Momentum(1, MomentumUnit.BaseUnit);
var numeric = new Numeric(1, NumericUnit.BaseUnit);
var power = new Power(1, PowerUnit.BaseUnit);
var pressure = new Pressure(1, PressureUnit.BaseUnit);
var speed = new Speed(1, SpeedUnit.BaseUnit);
var temperature = new Temperature(1, TemperatureUnit.BaseUnit);
var time = new Time(1, TimeUnit.BaseUnit);
var torque = new Torque(1, TorqueUnit.BaseUnit);
var volume = new Volume(1, VolumeUnit.BaseUnit);
var volumetricFlowRate = new VolumetricFlowRate(1, VolumetricFlowRateUnit.BaseUnit);
}
public void OpAddition()
{
var torque1 = new Torque(9.81, TorqueUnit.NewtonMeters);
var torque2 = new Torque(1, TorqueUnit.KilogramForceMeters);
var expected = new Torque(19.62, TorqueUnit.NewtonMeters);
(torque1 + torque2).ShouldEqual(expected);
(torque2 + torque1).ShouldEqual(expected);
}
public void OpDivision()
{
var torque1 = new Torque(19.62, TorqueUnit.NewtonMeters);
var torque2 = new Torque(2, TorqueUnit.KilogramForceMeters);
(torque1 / torque2).ShouldBeWithinEpsilonOf(1);
(torque2 / torque1).ShouldBeWithinEpsilonOf(1);
(torque1 / 2).ShouldEqual(new Torque(9.81, TorqueUnit.NewtonMeters));
(torque2 / 2).ShouldEqual(new Torque(1, TorqueUnit.KilogramForceMeters));
}
public void OpGreaterThanOrEqual()
{
var torque1 = new Torque(19.62, TorqueUnit.NewtonMeters);
var torque2 = new Torque(2, TorqueUnit.KilogramForceMeters);
var torque3 = new Torque(3, TorqueUnit.KilogramForceMeters);
(torque1 >= torque3).ShouldBeFalse();
(torque3 >= torque1).ShouldBeTrue();
(torque1 >= torque2).ShouldBeTrue();
(torque2 >= torque1).ShouldBeTrue();
}
public void OpInverseEquals()
{
var torque1 = new Torque(19.62, TorqueUnit.NewtonMeters);
var torque2 = new Torque(2, TorqueUnit.KilogramForceMeters);
var torque3 = new Torque(3, TorqueUnit.KilogramForceMeters);
(torque1 != torque2).ShouldBeFalse();
(torque2 != torque1).ShouldBeFalse();
(torque1 != torque3).ShouldBeTrue();
(torque3 != torque1).ShouldBeTrue();
}
public void OpEquals()
{
var torque1 = new Torque(19.62, TorqueUnit.NewtonMeters);
var torque2 = new Torque(2, TorqueUnit.KilogramForceMeters);
var torque3 = new Torque(3, TorqueUnit.KilogramForceMeters);
(torque1 == torque2).ShouldBeTrue();
(torque2 == torque1).ShouldBeTrue();
(torque1 == torque3).ShouldBeFalse();
(torque3 == torque1).ShouldBeFalse();
torque1.Equals(torque2)
.ShouldBeTrue();
torque1.Equals((object)torque2)
.ShouldBeTrue();
torque2.Equals(torque1)
.ShouldBeTrue();
torque2.Equals((object)torque1)
.ShouldBeTrue();
}
/// <inheritdoc cref="Torque.FromKilogramForceMeters(double?)"/> public static Torque?KilogramForceMeters(this double?value) => Torque.FromKilogramForceMeters(value);
/// <inheritdoc cref="Torque.FromKilogramForceCentimeters(double?)"/> public static Torque?KilogramForceCentimeters(this decimal?value) => Torque.FromKilogramForceCentimeters(value == null ? (double?)null : Convert.ToDouble(value.Value));
public void CompareToThrowsOnTypeMismatch()
{
Torque newtonmeter = Torque.FromNewtonMeters(1);
Assert.Throws <ArgumentException>(() => newtonmeter.CompareTo(new object()));
}
public void EqualsReturnsFalseOnTypeMismatch()
{
Torque newtonmeter = Torque.FromNewtonMeters(1);
Assert.False(newtonmeter.Equals(new object()));
}
public void Convert_ToSingle_EqualsValueAsSameType()
{
var quantity = Torque.FromNewtonMeters(1.0);
Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity));
}
public void Convert_ToUInt64_EqualsValueAsSameType()
{
var quantity = Torque.FromNewtonMeters(1.0);
Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity));
}
public void GetHashCode_Equals()
{
var quantity = Torque.FromNewtonMeters(1.0);
Assert.Equal(new { Torque.QuantityType, quantity.Value, quantity.Unit }.GetHashCode(), quantity.GetHashCode());
}
public void Convert_ToDecimal_EqualsValueAsSameType()
{
var quantity = Torque.FromNewtonMeters(1.0);
Assert.Equal((decimal)quantity.Value, Convert.ToDecimal(quantity));
}
public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions()
{
var quantity = Torque.FromNewtonMeters(1.0);
Assert.Equal(Torque.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions)));
}
public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException()
{
var quantity = Torque.FromNewtonMeters(1.0);
Assert.Throws <InvalidCastException>(() => Convert.ChangeType(quantity, typeof(QuantityFormatter)));
}
public void Convert_ChangeType_QuantityType_EqualsQuantityType()
{
var quantity = Torque.FromNewtonMeters(1.0);
Assert.Equal(QuantityType.Torque, Convert.ChangeType(quantity, typeof(QuantityType)));
}
public void Convert_ChangeType_UnitType_EqualsUnit()
{
var quantity = Torque.FromNewtonMeters(1.0);
Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(TorqueUnit)));
}
public void Convert_ChangeType_SelfType_EqualsSelf()
{
var quantity = Torque.FromNewtonMeters(1.0);
Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(Torque)));
}
public void ToString_NullProvider_EqualsCurrentUICulture()
{
var quantity = Torque.FromNewtonMeters(1.0);
Assert.Equal(quantity.ToString(CultureInfo.CurrentUICulture, "g"), quantity.ToString(null, "g"));
}
public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value)
{
var quantity = Torque.FromNewtonMeters(value);
Assert.Equal(Torque.FromNewtonMeters(-value), -quantity);
}
public void Convert_ToDateTime_ThrowsInvalidCastException()
{
var quantity = Torque.FromNewtonMeters(1.0);
Assert.Throws <InvalidCastException>(() => Convert.ToDateTime(quantity));
}
public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
{
var quantity00 = Torque.From(1, TorqueUnit.KilogramForceCentimeter);
AssertEx.EqualTolerance(1, quantity00.KilogramForceCentimeters, KilogramForceCentimetersTolerance);
Assert.Equal(TorqueUnit.KilogramForceCentimeter, quantity00.Unit);
var quantity01 = Torque.From(1, TorqueUnit.KilogramForceMeter);
AssertEx.EqualTolerance(1, quantity01.KilogramForceMeters, KilogramForceMetersTolerance);
Assert.Equal(TorqueUnit.KilogramForceMeter, quantity01.Unit);
var quantity02 = Torque.From(1, TorqueUnit.KilogramForceMillimeter);
AssertEx.EqualTolerance(1, quantity02.KilogramForceMillimeters, KilogramForceMillimetersTolerance);
Assert.Equal(TorqueUnit.KilogramForceMillimeter, quantity02.Unit);
var quantity03 = Torque.From(1, TorqueUnit.KilonewtonCentimeter);
AssertEx.EqualTolerance(1, quantity03.KilonewtonCentimeters, KilonewtonCentimetersTolerance);
Assert.Equal(TorqueUnit.KilonewtonCentimeter, quantity03.Unit);
var quantity04 = Torque.From(1, TorqueUnit.KilonewtonMeter);
AssertEx.EqualTolerance(1, quantity04.KilonewtonMeters, KilonewtonMetersTolerance);
Assert.Equal(TorqueUnit.KilonewtonMeter, quantity04.Unit);
var quantity05 = Torque.From(1, TorqueUnit.KilonewtonMillimeter);
AssertEx.EqualTolerance(1, quantity05.KilonewtonMillimeters, KilonewtonMillimetersTolerance);
Assert.Equal(TorqueUnit.KilonewtonMillimeter, quantity05.Unit);
var quantity06 = Torque.From(1, TorqueUnit.KilopoundForceFoot);
AssertEx.EqualTolerance(1, quantity06.KilopoundForceFeet, KilopoundForceFeetTolerance);
Assert.Equal(TorqueUnit.KilopoundForceFoot, quantity06.Unit);
var quantity07 = Torque.From(1, TorqueUnit.KilopoundForceInch);
AssertEx.EqualTolerance(1, quantity07.KilopoundForceInches, KilopoundForceInchesTolerance);
Assert.Equal(TorqueUnit.KilopoundForceInch, quantity07.Unit);
var quantity08 = Torque.From(1, TorqueUnit.MeganewtonCentimeter);
AssertEx.EqualTolerance(1, quantity08.MeganewtonCentimeters, MeganewtonCentimetersTolerance);
Assert.Equal(TorqueUnit.MeganewtonCentimeter, quantity08.Unit);
var quantity09 = Torque.From(1, TorqueUnit.MeganewtonMeter);
AssertEx.EqualTolerance(1, quantity09.MeganewtonMeters, MeganewtonMetersTolerance);
Assert.Equal(TorqueUnit.MeganewtonMeter, quantity09.Unit);
var quantity10 = Torque.From(1, TorqueUnit.MeganewtonMillimeter);
AssertEx.EqualTolerance(1, quantity10.MeganewtonMillimeters, MeganewtonMillimetersTolerance);
Assert.Equal(TorqueUnit.MeganewtonMillimeter, quantity10.Unit);
var quantity11 = Torque.From(1, TorqueUnit.MegapoundForceFoot);
AssertEx.EqualTolerance(1, quantity11.MegapoundForceFeet, MegapoundForceFeetTolerance);
Assert.Equal(TorqueUnit.MegapoundForceFoot, quantity11.Unit);
var quantity12 = Torque.From(1, TorqueUnit.MegapoundForceInch);
AssertEx.EqualTolerance(1, quantity12.MegapoundForceInches, MegapoundForceInchesTolerance);
Assert.Equal(TorqueUnit.MegapoundForceInch, quantity12.Unit);
var quantity13 = Torque.From(1, TorqueUnit.NewtonCentimeter);
AssertEx.EqualTolerance(1, quantity13.NewtonCentimeters, NewtonCentimetersTolerance);
Assert.Equal(TorqueUnit.NewtonCentimeter, quantity13.Unit);
var quantity14 = Torque.From(1, TorqueUnit.NewtonMeter);
AssertEx.EqualTolerance(1, quantity14.NewtonMeters, NewtonMetersTolerance);
Assert.Equal(TorqueUnit.NewtonMeter, quantity14.Unit);
var quantity15 = Torque.From(1, TorqueUnit.NewtonMillimeter);
AssertEx.EqualTolerance(1, quantity15.NewtonMillimeters, NewtonMillimetersTolerance);
Assert.Equal(TorqueUnit.NewtonMillimeter, quantity15.Unit);
var quantity16 = Torque.From(1, TorqueUnit.PoundalFoot);
AssertEx.EqualTolerance(1, quantity16.PoundalFeet, PoundalFeetTolerance);
Assert.Equal(TorqueUnit.PoundalFoot, quantity16.Unit);
var quantity17 = Torque.From(1, TorqueUnit.PoundForceFoot);
AssertEx.EqualTolerance(1, quantity17.PoundForceFeet, PoundForceFeetTolerance);
Assert.Equal(TorqueUnit.PoundForceFoot, quantity17.Unit);
var quantity18 = Torque.From(1, TorqueUnit.PoundForceInch);
AssertEx.EqualTolerance(1, quantity18.PoundForceInches, PoundForceInchesTolerance);
Assert.Equal(TorqueUnit.PoundForceInch, quantity18.Unit);
var quantity19 = Torque.From(1, TorqueUnit.TonneForceCentimeter);
AssertEx.EqualTolerance(1, quantity19.TonneForceCentimeters, TonneForceCentimetersTolerance);
Assert.Equal(TorqueUnit.TonneForceCentimeter, quantity19.Unit);
var quantity20 = Torque.From(1, TorqueUnit.TonneForceMeter);
AssertEx.EqualTolerance(1, quantity20.TonneForceMeters, TonneForceMetersTolerance);
Assert.Equal(TorqueUnit.TonneForceMeter, quantity20.Unit);
var quantity21 = Torque.From(1, TorqueUnit.TonneForceMillimeter);
AssertEx.EqualTolerance(1, quantity21.TonneForceMillimeters, TonneForceMillimetersTolerance);
Assert.Equal(TorqueUnit.TonneForceMillimeter, quantity21.Unit);
}
public void Convert_ToInt32_EqualsValueAsSameType()
{
var quantity = Torque.FromNewtonMeters(1.0);
Assert.Equal((int)quantity.Value, Convert.ToInt32(quantity));
}
public void FromNewtonMeters_WithInfinityValue_ThrowsArgumentException()
{
Assert.Throws <ArgumentException>(() => Torque.FromNewtonMeters(double.PositiveInfinity));
Assert.Throws <ArgumentException>(() => Torque.FromNewtonMeters(double.NegativeInfinity));
}
public void Convert_ToString_EqualsToString()
{
var quantity = Torque.FromNewtonMeters(1.0);
Assert.Equal(quantity.ToString(), Convert.ToString(quantity));
}
public void FromNewtonMeters_WithNanValue_ThrowsArgumentException()
{
Assert.Throws <ArgumentException>(() => Torque.FromNewtonMeters(double.NaN));
}
public void ToUnit()
{
var newtonmeter = Torque.FromNewtonMeters(1);
var kilogramforcecentimeterQuantity = newtonmeter.ToUnit(TorqueUnit.KilogramForceCentimeter);
AssertEx.EqualTolerance(KilogramForceCentimetersInOneNewtonMeter, (double)kilogramforcecentimeterQuantity.Value, KilogramForceCentimetersTolerance);
Assert.Equal(TorqueUnit.KilogramForceCentimeter, kilogramforcecentimeterQuantity.Unit);
var kilogramforcemeterQuantity = newtonmeter.ToUnit(TorqueUnit.KilogramForceMeter);
AssertEx.EqualTolerance(KilogramForceMetersInOneNewtonMeter, (double)kilogramforcemeterQuantity.Value, KilogramForceMetersTolerance);
Assert.Equal(TorqueUnit.KilogramForceMeter, kilogramforcemeterQuantity.Unit);
var kilogramforcemillimeterQuantity = newtonmeter.ToUnit(TorqueUnit.KilogramForceMillimeter);
AssertEx.EqualTolerance(KilogramForceMillimetersInOneNewtonMeter, (double)kilogramforcemillimeterQuantity.Value, KilogramForceMillimetersTolerance);
Assert.Equal(TorqueUnit.KilogramForceMillimeter, kilogramforcemillimeterQuantity.Unit);
var kilonewtoncentimeterQuantity = newtonmeter.ToUnit(TorqueUnit.KilonewtonCentimeter);
AssertEx.EqualTolerance(KilonewtonCentimetersInOneNewtonMeter, (double)kilonewtoncentimeterQuantity.Value, KilonewtonCentimetersTolerance);
Assert.Equal(TorqueUnit.KilonewtonCentimeter, kilonewtoncentimeterQuantity.Unit);
var kilonewtonmeterQuantity = newtonmeter.ToUnit(TorqueUnit.KilonewtonMeter);
AssertEx.EqualTolerance(KilonewtonMetersInOneNewtonMeter, (double)kilonewtonmeterQuantity.Value, KilonewtonMetersTolerance);
Assert.Equal(TorqueUnit.KilonewtonMeter, kilonewtonmeterQuantity.Unit);
var kilonewtonmillimeterQuantity = newtonmeter.ToUnit(TorqueUnit.KilonewtonMillimeter);
AssertEx.EqualTolerance(KilonewtonMillimetersInOneNewtonMeter, (double)kilonewtonmillimeterQuantity.Value, KilonewtonMillimetersTolerance);
Assert.Equal(TorqueUnit.KilonewtonMillimeter, kilonewtonmillimeterQuantity.Unit);
var kilopoundforcefootQuantity = newtonmeter.ToUnit(TorqueUnit.KilopoundForceFoot);
AssertEx.EqualTolerance(KilopoundForceFeetInOneNewtonMeter, (double)kilopoundforcefootQuantity.Value, KilopoundForceFeetTolerance);
Assert.Equal(TorqueUnit.KilopoundForceFoot, kilopoundforcefootQuantity.Unit);
var kilopoundforceinchQuantity = newtonmeter.ToUnit(TorqueUnit.KilopoundForceInch);
AssertEx.EqualTolerance(KilopoundForceInchesInOneNewtonMeter, (double)kilopoundforceinchQuantity.Value, KilopoundForceInchesTolerance);
Assert.Equal(TorqueUnit.KilopoundForceInch, kilopoundforceinchQuantity.Unit);
var meganewtoncentimeterQuantity = newtonmeter.ToUnit(TorqueUnit.MeganewtonCentimeter);
AssertEx.EqualTolerance(MeganewtonCentimetersInOneNewtonMeter, (double)meganewtoncentimeterQuantity.Value, MeganewtonCentimetersTolerance);
Assert.Equal(TorqueUnit.MeganewtonCentimeter, meganewtoncentimeterQuantity.Unit);
var meganewtonmeterQuantity = newtonmeter.ToUnit(TorqueUnit.MeganewtonMeter);
AssertEx.EqualTolerance(MeganewtonMetersInOneNewtonMeter, (double)meganewtonmeterQuantity.Value, MeganewtonMetersTolerance);
Assert.Equal(TorqueUnit.MeganewtonMeter, meganewtonmeterQuantity.Unit);
var meganewtonmillimeterQuantity = newtonmeter.ToUnit(TorqueUnit.MeganewtonMillimeter);
AssertEx.EqualTolerance(MeganewtonMillimetersInOneNewtonMeter, (double)meganewtonmillimeterQuantity.Value, MeganewtonMillimetersTolerance);
Assert.Equal(TorqueUnit.MeganewtonMillimeter, meganewtonmillimeterQuantity.Unit);
var megapoundforcefootQuantity = newtonmeter.ToUnit(TorqueUnit.MegapoundForceFoot);
AssertEx.EqualTolerance(MegapoundForceFeetInOneNewtonMeter, (double)megapoundforcefootQuantity.Value, MegapoundForceFeetTolerance);
Assert.Equal(TorqueUnit.MegapoundForceFoot, megapoundforcefootQuantity.Unit);
var megapoundforceinchQuantity = newtonmeter.ToUnit(TorqueUnit.MegapoundForceInch);
AssertEx.EqualTolerance(MegapoundForceInchesInOneNewtonMeter, (double)megapoundforceinchQuantity.Value, MegapoundForceInchesTolerance);
Assert.Equal(TorqueUnit.MegapoundForceInch, megapoundforceinchQuantity.Unit);
var newtoncentimeterQuantity = newtonmeter.ToUnit(TorqueUnit.NewtonCentimeter);
AssertEx.EqualTolerance(NewtonCentimetersInOneNewtonMeter, (double)newtoncentimeterQuantity.Value, NewtonCentimetersTolerance);
Assert.Equal(TorqueUnit.NewtonCentimeter, newtoncentimeterQuantity.Unit);
var newtonmeterQuantity = newtonmeter.ToUnit(TorqueUnit.NewtonMeter);
AssertEx.EqualTolerance(NewtonMetersInOneNewtonMeter, (double)newtonmeterQuantity.Value, NewtonMetersTolerance);
Assert.Equal(TorqueUnit.NewtonMeter, newtonmeterQuantity.Unit);
var newtonmillimeterQuantity = newtonmeter.ToUnit(TorqueUnit.NewtonMillimeter);
AssertEx.EqualTolerance(NewtonMillimetersInOneNewtonMeter, (double)newtonmillimeterQuantity.Value, NewtonMillimetersTolerance);
Assert.Equal(TorqueUnit.NewtonMillimeter, newtonmillimeterQuantity.Unit);
var poundforcefootQuantity = newtonmeter.ToUnit(TorqueUnit.PoundForceFoot);
AssertEx.EqualTolerance(PoundForceFeetInOneNewtonMeter, (double)poundforcefootQuantity.Value, PoundForceFeetTolerance);
Assert.Equal(TorqueUnit.PoundForceFoot, poundforcefootQuantity.Unit);
var poundforceinchQuantity = newtonmeter.ToUnit(TorqueUnit.PoundForceInch);
AssertEx.EqualTolerance(PoundForceInchesInOneNewtonMeter, (double)poundforceinchQuantity.Value, PoundForceInchesTolerance);
Assert.Equal(TorqueUnit.PoundForceInch, poundforceinchQuantity.Unit);
var tonneforcecentimeterQuantity = newtonmeter.ToUnit(TorqueUnit.TonneForceCentimeter);
AssertEx.EqualTolerance(TonneForceCentimetersInOneNewtonMeter, (double)tonneforcecentimeterQuantity.Value, TonneForceCentimetersTolerance);
Assert.Equal(TorqueUnit.TonneForceCentimeter, tonneforcecentimeterQuantity.Unit);
var tonneforcemeterQuantity = newtonmeter.ToUnit(TorqueUnit.TonneForceMeter);
AssertEx.EqualTolerance(TonneForceMetersInOneNewtonMeter, (double)tonneforcemeterQuantity.Value, TonneForceMetersTolerance);
Assert.Equal(TorqueUnit.TonneForceMeter, tonneforcemeterQuantity.Unit);
var tonneforcemillimeterQuantity = newtonmeter.ToUnit(TorqueUnit.TonneForceMillimeter);
AssertEx.EqualTolerance(TonneForceMillimetersInOneNewtonMeter, (double)tonneforcemillimeterQuantity.Value, TonneForceMillimetersTolerance);
Assert.Equal(TorqueUnit.TonneForceMillimeter, tonneforcemillimeterQuantity.Unit);
}
/// <inheritdoc cref="Torque.FromTonneForceMillimeters(double)"/> public static Torque TonneForceMillimeters(this decimal value) => Torque.FromTonneForceMillimeters(Convert.ToDouble(value));
public void CompareToThrowsOnNull()
{
Torque newtonmeter = Torque.FromNewtonMeters(1);
Assert.Throws <ArgumentNullException>(() => newtonmeter.CompareTo(null));
}
public void OpSubtraction()
{
var torque1 = new Torque(19.62, TorqueUnit.NewtonMeters);
var torque2 = new Torque(1, TorqueUnit.KilogramForceMeters);
(torque1 - torque2).ShouldEqual(new Torque(9.81, TorqueUnit.NewtonMeters));
(torque2 - torque1).ShouldEqual(new Torque(-1, TorqueUnit.KilogramForceMeters));
}
public void EqualsReturnsFalseOnNull()
{
Torque newtonmeter = Torque.FromNewtonMeters(1);
Assert.False(newtonmeter.Equals(null));
}
/// <inheritdoc cref="Torque.FromKilogramForceMeters(double)"/> public static Torque KilogramForceMeters(this long value) => Torque.FromKilogramForceMeters(value);
public void OpMultiplicationScaler()
{
var torque = new Torque(1, TorqueUnit.NewtonMeters);
var expected = new Torque(2, TorqueUnit.NewtonMeters);
(torque * 2).ShouldEqual(expected);
(2 * torque).ShouldEqual(expected);
}
protected void SetScalarValue(DependencyProperty property, Torque? quantity)
{
// we set this flag to prevent from setting scalar value changing quantity values.
this.isUpdatingScalarValue = true;
var value = quantity != null
? this.Unit.GetScalarValue(quantity.Value)
: (double?)null;
this.SetCurrentValue(property, value);
this.isUpdatingScalarValue = false;
}
public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
{
var quantityInBaseUnit = Torque.FromNewtonMeters(1).ToBaseUnit();
Assert.Equal(Torque.BaseUnit, quantityInBaseUnit.Unit);
}
/// <inheritdoc cref="Torque.FromTonneForceMillimeters(double?)"/> public static Torque?TonneForceMillimeters(this decimal?value) => Torque.FromTonneForceMillimeters(value == null ? (double?)null : Convert.ToDouble(value.Value));
public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
{
var v = Torque.FromNewtonMeters(1);
Assert.Throws <ArgumentOutOfRangeException>(() => v.Equals(Torque.FromNewtonMeters(1), -1, ComparisonType.Relative));
}
public void ToString_NullArgs_ThrowsArgumentNullException()
{
var quantity = Torque.FromNewtonMeters(1.0);
Assert.Throws <ArgumentNullException>(() => quantity.ToString(null, "g", null));
}
public void OpLessThan()
{
var torque1 = new Torque(19.62, TorqueUnit.NewtonMeters);
var torque2 = new Torque(2, TorqueUnit.KilogramForceMeters);
var torque3 = new Torque(3, TorqueUnit.KilogramForceMeters);
(torque1 < torque3).ShouldBeTrue();
(torque3 < torque1).ShouldBeFalse();
(torque1 < torque2).ShouldBeFalse();
(torque2 < torque1).ShouldBeFalse();
}
protected virtual void OnMaxValueChanged(Torque? oldValue, Torque? newValue)
{
this.SetScalarValue(ScalarMaxValueProperty, newValue);
}
