public void ForceDividedByAccelerationEqualsMass() { Mass acceleration = Force.FromNewtons(200) / Acceleration.FromMeterPerSecondSquared(50); Assert.Equal(acceleration, Mass.FromKilograms(4)); }
public void Convert_ToSByte_EqualsValueAsSameType() { var quantity = Force.FromNewtons(1.0); Assert.Equal((sbyte)quantity.Value, Convert.ToSByte(quantity)); }
public void Convert_ToString_EqualsToString() { var quantity = Force.FromNewtons(1.0); Assert.Equal(quantity.ToString(), Convert.ToString(quantity)); }
public void ToString_NullProvider_EqualsCurrentUICulture() { var quantity = Force.FromNewtons(1.0); Assert.Equal(quantity.ToString(CultureInfo.CurrentUICulture, "g"), quantity.ToString(null, "g")); }
public void Convert_ToDecimal_EqualsValueAsSameType() { var quantity = Force.FromNewtons(1.0); Assert.Equal((decimal)quantity.Value, Convert.ToDecimal(quantity)); }
public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException() { var v = Force.FromNewtons(1); Assert.Throws <ArgumentOutOfRangeException>(() => v.Equals(Force.FromNewtons(1), -1, ComparisonType.Relative)); }
public void EqualsReturnsFalseOnNull() { Force newton = Force.FromNewtons(1); Assert.False(newton.Equals(null)); }
public static Force?Newtons <T>(this T?value) where T : struct => Force.FromNewtons(value == null ? (double?)null : Convert.ToDouble(value.Value));
public void AccelerationTimesMassEqualsForce() { Force force = Acceleration.FromMetersPerSecondSquared(3) * Mass.FromKilograms(18); Assert.Equal(force, Force.FromNewtons(54)); }
public void ForceTimesLengthEqualsTorque() { Torque torque = Force.FromNewtons(1) * Length.FromMeters(3); Assert.Equal(torque, Torque.FromNewtonMeters(3)); }
/// <inheritdoc cref="Force.FromNewtons(UnitsNet.QuantityValue)" /> public static Force Newtons <T>(this T value) => Force.FromNewtons(Convert.ToDouble(value));
public void LengthTimesForceEqualsTorque() { Torque torque = Length.FromMeters(3) * Force.FromNewtons(1); Assert.Equal(torque, Torque.FromNewtonMeters(3)); }
public void MassByAccelerationEqualsForceUsingDouble() { var force = Force.FromMassByAcceleration(Mass.FromKilograms(9), 3); Assert.Equal(force, Force.FromNewtons(27)); }
public void ForceDividedByLengthEqualsForcePerLength() { ForcePerLength forcePerLength = Force.FromNewtons(200) / Length.FromMeters(50); Assert.Equal(forcePerLength, ForcePerLength.FromNewtonsPerMeter(4)); }
public void CompareToThrowsOnTypeMismatch() { Force newton = Force.FromNewtons(1); Assert.Throws <ArgumentException>(() => newton.CompareTo(new object())); }
/// <summary>Get <see cref="Force"/> from <see cref="Pressure"/> times <see cref="Area"/>.</summary> public static Force operator *(Pressure pressure, Area area) { return(Force.FromNewtons(pressure.Pascals * area.SquareMeters)); }
public void CompareToThrowsOnNull() { Force newton = Force.FromNewtons(1); Assert.Throws <ArgumentNullException>(() => newton.CompareTo(null)); }
public static Force operator /(Torque torque, Length length) { return(Force.FromNewtons(torque.NewtonMeters / length.Meters)); }
public void EqualsReturnsFalseOnTypeMismatch() { Force newton = Force.FromNewtons(1); Assert.False(newton.Equals(new object())); }
public void AreaTimesPressureEqualsForce() { var force = Area.FromSquareMeters(3) * Pressure.FromPascals(20); Assert.Equal(force, Force.FromNewtons(60)); }
public void ToString_NullArgs_ThrowsArgumentNullException() { var quantity = Force.FromNewtons(1.0); Assert.Throws <ArgumentNullException>(() => quantity.ToString(null, "g", null)); }
public void PressureTimesAreaEqualsForce() { var force = Pressure.FromPascals(20) * Area.FromSquareMeters(3); Assert.Equal(force, Force.FromNewtons(60)); }
public void Convert_ToDateTime_ThrowsInvalidCastException() { var quantity = Force.FromNewtons(1.0); Assert.Throws <InvalidCastException>(() => Convert.ToDateTime(quantity)); }
public void FromNewtons_WithInfinityValue_ThrowsArgumentException() { Assert.Throws <ArgumentException>(() => Force.FromNewtons(double.PositiveInfinity)); Assert.Throws <ArgumentException>(() => Force.FromNewtons(double.NegativeInfinity)); }
public void Convert_ToInt32_EqualsValueAsSameType() { var quantity = Force.FromNewtons(1.0); Assert.Equal((int)quantity.Value, Convert.ToInt32(quantity)); }
public void FromNewtons_WithNanValue_ThrowsArgumentException() { Assert.Throws <ArgumentException>(() => Force.FromNewtons(double.NaN)); }
public void Convert_ToSingle_EqualsValueAsSameType() { var quantity = Force.FromNewtons(1.0); Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity)); }
public void ToUnit() { var newton = Force.FromNewtons(1); var decanewtonQuantity = newton.ToUnit(ForceUnit.Decanewton); AssertEx.EqualTolerance(DecanewtonsInOneNewton, (double)decanewtonQuantity.Value, DecanewtonsTolerance); Assert.Equal(ForceUnit.Decanewton, decanewtonQuantity.Unit); var dynQuantity = newton.ToUnit(ForceUnit.Dyn); AssertEx.EqualTolerance(DyneInOneNewton, (double)dynQuantity.Value, DyneTolerance); Assert.Equal(ForceUnit.Dyn, dynQuantity.Unit); var kilogramforceQuantity = newton.ToUnit(ForceUnit.KilogramForce); AssertEx.EqualTolerance(KilogramsForceInOneNewton, (double)kilogramforceQuantity.Value, KilogramsForceTolerance); Assert.Equal(ForceUnit.KilogramForce, kilogramforceQuantity.Unit); var kilonewtonQuantity = newton.ToUnit(ForceUnit.Kilonewton); AssertEx.EqualTolerance(KilonewtonsInOneNewton, (double)kilonewtonQuantity.Value, KilonewtonsTolerance); Assert.Equal(ForceUnit.Kilonewton, kilonewtonQuantity.Unit); var kilopondQuantity = newton.ToUnit(ForceUnit.KiloPond); AssertEx.EqualTolerance(KiloPondsInOneNewton, (double)kilopondQuantity.Value, KiloPondsTolerance); Assert.Equal(ForceUnit.KiloPond, kilopondQuantity.Unit); var kilopoundforceQuantity = newton.ToUnit(ForceUnit.KilopoundForce); AssertEx.EqualTolerance(KilopoundsForceInOneNewton, (double)kilopoundforceQuantity.Value, KilopoundsForceTolerance); Assert.Equal(ForceUnit.KilopoundForce, kilopoundforceQuantity.Unit); var meganewtonQuantity = newton.ToUnit(ForceUnit.Meganewton); AssertEx.EqualTolerance(MeganewtonsInOneNewton, (double)meganewtonQuantity.Value, MeganewtonsTolerance); Assert.Equal(ForceUnit.Meganewton, meganewtonQuantity.Unit); var micronewtonQuantity = newton.ToUnit(ForceUnit.Micronewton); AssertEx.EqualTolerance(MicronewtonsInOneNewton, (double)micronewtonQuantity.Value, MicronewtonsTolerance); Assert.Equal(ForceUnit.Micronewton, micronewtonQuantity.Unit); var millinewtonQuantity = newton.ToUnit(ForceUnit.Millinewton); AssertEx.EqualTolerance(MillinewtonsInOneNewton, (double)millinewtonQuantity.Value, MillinewtonsTolerance); Assert.Equal(ForceUnit.Millinewton, millinewtonQuantity.Unit); var newtonQuantity = newton.ToUnit(ForceUnit.Newton); AssertEx.EqualTolerance(NewtonsInOneNewton, (double)newtonQuantity.Value, NewtonsTolerance); Assert.Equal(ForceUnit.Newton, newtonQuantity.Unit); var ounceforceQuantity = newton.ToUnit(ForceUnit.OunceForce); AssertEx.EqualTolerance(OunceForceInOneNewton, (double)ounceforceQuantity.Value, OunceForceTolerance); Assert.Equal(ForceUnit.OunceForce, ounceforceQuantity.Unit); var poundalQuantity = newton.ToUnit(ForceUnit.Poundal); AssertEx.EqualTolerance(PoundalsInOneNewton, (double)poundalQuantity.Value, PoundalsTolerance); Assert.Equal(ForceUnit.Poundal, poundalQuantity.Unit); var poundforceQuantity = newton.ToUnit(ForceUnit.PoundForce); AssertEx.EqualTolerance(PoundsForceInOneNewton, (double)poundforceQuantity.Value, PoundsForceTolerance); Assert.Equal(ForceUnit.PoundForce, poundforceQuantity.Unit); var tonneforceQuantity = newton.ToUnit(ForceUnit.TonneForce); AssertEx.EqualTolerance(TonnesForceInOneNewton, (double)tonneforceQuantity.Value, TonnesForceTolerance); Assert.Equal(ForceUnit.TonneForce, tonneforceQuantity.Unit); }
public void Convert_ToUInt64_EqualsValueAsSameType() { var quantity = Force.FromNewtons(1.0); Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity)); }
public void ForceDividedByMassEqualsAcceleration() { Acceleration acceleration = Force.FromNewtons(27) / Mass.FromKilograms(9); Assert.Equal(acceleration, Acceleration.FromMeterPerSecondSquared(3)); }