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