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); }