public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
{
var quantity = new ApparentEnergy();
Assert.Equal(0, quantity.Value);
Assert.Equal(ApparentEnergyUnit.VoltampereHour, quantity.Unit);
}
public void CompareToIsImplemented()
{
ApparentEnergy voltamperehour = ApparentEnergy.FromVoltampereHours(1);
Assert.Equal(0, voltamperehour.CompareTo(voltamperehour));
Assert.True(voltamperehour.CompareTo(ApparentEnergy.Zero) > 0);
Assert.True(ApparentEnergy.Zero.CompareTo(voltamperehour) < 0);
}
public void ConversionRoundTrip()
{
ApparentEnergy voltamperehour = ApparentEnergy.FromVoltampereHours(1);
AssertEx.EqualTolerance(1, ApparentEnergy.FromKilovoltampereHours(voltamperehour.KilovoltampereHours).VoltampereHours, KilovoltampereHoursTolerance);
AssertEx.EqualTolerance(1, ApparentEnergy.FromMegavoltampereHours(voltamperehour.MegavoltampereHours).VoltampereHours, MegavoltampereHoursTolerance);
AssertEx.EqualTolerance(1, ApparentEnergy.FromVoltampereHours(voltamperehour.VoltampereHours).VoltampereHours, VoltampereHoursTolerance);
}
public void EqualsRelativeToleranceIsImplemented()
{
var v = ApparentEnergy.FromVoltampereHours(1);
Assert.True(v.Equals(ApparentEnergy.FromVoltampereHours(1), VoltampereHoursTolerance, ComparisonType.Relative));
Assert.False(v.Equals(ApparentEnergy.Zero, VoltampereHoursTolerance, ComparisonType.Relative));
}
public void As()
{
var voltamperehour = ApparentEnergy.FromVoltampereHours(1);
AssertEx.EqualTolerance(KilovoltampereHoursInOneVoltampereHour, voltamperehour.As(ApparentEnergyUnit.KilovoltampereHour), KilovoltampereHoursTolerance);
AssertEx.EqualTolerance(MegavoltampereHoursInOneVoltampereHour, voltamperehour.As(ApparentEnergyUnit.MegavoltampereHour), MegavoltampereHoursTolerance);
AssertEx.EqualTolerance(VoltampereHoursInOneVoltampereHour, voltamperehour.As(ApparentEnergyUnit.VoltampereHour), VoltampereHoursTolerance);
}
public void EqualsIsImplemented()
{
ApparentEnergy v = ApparentEnergy.FromVoltampereHours(1);
Assert.True(v.Equals(ApparentEnergy.FromVoltampereHours(1), ApparentEnergy.FromVoltampereHours(VoltampereHoursTolerance)));
Assert.False(v.Equals(ApparentEnergy.Zero, ApparentEnergy.FromVoltampereHours(VoltampereHoursTolerance)));
}
public void VoltampereHourToApparentEnergyUnits()
{
ApparentEnergy voltamperehour = ApparentEnergy.FromVoltampereHours(1);
AssertEx.EqualTolerance(KilovoltampereHoursInOneVoltampereHour, voltamperehour.KilovoltampereHours, KilovoltampereHoursTolerance);
AssertEx.EqualTolerance(MegavoltampereHoursInOneVoltampereHour, voltamperehour.MegavoltampereHours, MegavoltampereHoursTolerance);
AssertEx.EqualTolerance(VoltampereHoursInOneVoltampereHour, voltamperehour.VoltampereHours, VoltampereHoursTolerance);
}
public void Ctor_WithInfinityValue_CreateQuantityAndAffectInfinityValue()
{
var positiveInfinityQuantity = new ApparentEnergy(double.PositiveInfinity, ApparentEnergyUnit.VoltampereHour);
var negativeInfinityQuantity = new ApparentEnergy(double.NegativeInfinity, ApparentEnergyUnit.VoltampereHour);
Assert.True(double.IsPositiveInfinity(positiveInfinityQuantity.Value));
Assert.True(double.IsNegativeInfinity(negativeInfinityQuantity.Value));
}
public void FromVoltampereHours_WithInfinityValue_CreateQuantityAndAffectInfinityValue()
{
var positiveInfinityQuantity = ApparentEnergy.FromVoltampereHours(double.PositiveInfinity);
var negativeInfinityQuantity = ApparentEnergy.FromVoltampereHours(double.NegativeInfinity);
Assert.True(double.IsPositiveInfinity(positiveInfinityQuantity.Value));
Assert.True(double.IsNegativeInfinity(negativeInfinityQuantity.Value));
}
public void Equals_SameType_IsImplemented()
{
var a = ApparentEnergy.FromVoltampereHours(1);
var b = ApparentEnergy.FromVoltampereHours(2);
Assert.True(a.Equals(a));
Assert.False(a.Equals(b));
}
public void Equals_QuantityAsObject_IsImplemented()
{
object a = ApparentEnergy.FromVoltampereHours(1);
object b = ApparentEnergy.FromVoltampereHours(2);
Assert.True(a.Equals(a));
Assert.False(a.Equals(b));
Assert.False(a.Equals((object)null));
}
public void ArithmeticOperators()
{
ApparentEnergy v = ApparentEnergy.FromVoltampereHours(1);
AssertEx.EqualTolerance(-1, -v.VoltampereHours, VoltampereHoursTolerance);
AssertEx.EqualTolerance(2, (ApparentEnergy.FromVoltampereHours(3)-v).VoltampereHours, VoltampereHoursTolerance);
AssertEx.EqualTolerance(2, (v + v).VoltampereHours, VoltampereHoursTolerance);
AssertEx.EqualTolerance(10, (v*10).VoltampereHours, VoltampereHoursTolerance);
AssertEx.EqualTolerance(10, (10*v).VoltampereHours, VoltampereHoursTolerance);
AssertEx.EqualTolerance(2, (ApparentEnergy.FromVoltampereHours(10)/5).VoltampereHours, VoltampereHoursTolerance);
AssertEx.EqualTolerance(2, ApparentEnergy.FromVoltampereHours(10)/ApparentEnergy.FromVoltampereHours(5), VoltampereHoursTolerance);
}
public void To_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
{
var voltamperehour = ApparentEnergy.FromVoltampereHours(1);
Assert.Throws <ArgumentException>(() => voltamperehour.ToUnit(UnitSystem.SI));
Assert.Throws <ArgumentException>(() => voltamperehour.ToUnit(UnitSystem.CGS));
Assert.Throws <ArgumentException>(() => voltamperehour.ToUnit(UnitSystem.BI));
Assert.Throws <ArgumentException>(() => voltamperehour.ToUnit(UnitSystem.EE));
Assert.Throws <ArgumentException>(() => voltamperehour.ToUnit(UnitSystem.USC));
Assert.Throws <ArgumentException>(() => voltamperehour.ToUnit(UnitSystem.FPS));
Assert.Throws <ArgumentException>(() => voltamperehour.ToUnit(UnitSystem.Astronomical));
}
public void EqualityOperators()
{
ApparentEnergy a = ApparentEnergy.FromVoltampereHours(1);
ApparentEnergy b = ApparentEnergy.FromVoltampereHours(2);
// ReSharper disable EqualExpressionComparison
Assert.True(a == a);
Assert.True(a != b);
Assert.False(a == b);
Assert.False(a != a);
// ReSharper restore EqualExpressionComparison
}
public void ComparisonOperators()
{
ApparentEnergy oneVoltampereHour = ApparentEnergy.FromVoltampereHours(1);
ApparentEnergy twoVoltampereHours = ApparentEnergy.FromVoltampereHours(2);
Assert.True(oneVoltampereHour < twoVoltampereHours);
Assert.True(oneVoltampereHour <= twoVoltampereHours);
Assert.True(twoVoltampereHours > oneVoltampereHour);
Assert.True(twoVoltampereHours >= oneVoltampereHour);
Assert.False(oneVoltampereHour > twoVoltampereHours);
Assert.False(oneVoltampereHour >= twoVoltampereHours);
Assert.False(twoVoltampereHours < oneVoltampereHour);
Assert.False(twoVoltampereHours <= oneVoltampereHour);
}
public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
{
var quantity = new ApparentEnergy(value: 1, unit: ApparentEnergy.BaseUnit);
Func <object> AsWithSIUnitSystem = () => quantity.As(UnitSystem.SI);
if (SupportsSIUnitSystem)
{
var value = (double)AsWithSIUnitSystem();
Assert.Equal(1, value);
}
else
{
Assert.Throws <ArgumentException>(AsWithSIUnitSystem);
}
}
public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
{
var quantity00 = ApparentEnergy.From(1, ApparentEnergyUnit.KilovoltampereHour);
AssertEx.EqualTolerance(1, quantity00.KilovoltampereHours, KilovoltampereHoursTolerance);
Assert.Equal(ApparentEnergyUnit.KilovoltampereHour, quantity00.Unit);
var quantity01 = ApparentEnergy.From(1, ApparentEnergyUnit.MegavoltampereHour);
AssertEx.EqualTolerance(1, quantity01.MegavoltampereHours, MegavoltampereHoursTolerance);
Assert.Equal(ApparentEnergyUnit.MegavoltampereHour, quantity01.Unit);
var quantity02 = ApparentEnergy.From(1, ApparentEnergyUnit.VoltampereHour);
AssertEx.EqualTolerance(1, quantity02.VoltampereHours, VoltampereHoursTolerance);
Assert.Equal(ApparentEnergyUnit.VoltampereHour, quantity02.Unit);
}
public void ToUnit()
{
var voltamperehour = ApparentEnergy.FromVoltampereHours(1);
var kilovoltamperehourQuantity = voltamperehour.ToUnit(ApparentEnergyUnit.KilovoltampereHour);
AssertEx.EqualTolerance(KilovoltampereHoursInOneVoltampereHour, (double)kilovoltamperehourQuantity.Value, KilovoltampereHoursTolerance);
Assert.Equal(ApparentEnergyUnit.KilovoltampereHour, kilovoltamperehourQuantity.Unit);
var megavoltamperehourQuantity = voltamperehour.ToUnit(ApparentEnergyUnit.MegavoltampereHour);
AssertEx.EqualTolerance(MegavoltampereHoursInOneVoltampereHour, (double)megavoltamperehourQuantity.Value, MegavoltampereHoursTolerance);
Assert.Equal(ApparentEnergyUnit.MegavoltampereHour, megavoltamperehourQuantity.Unit);
var voltamperehourQuantity = voltamperehour.ToUnit(ApparentEnergyUnit.VoltampereHour);
AssertEx.EqualTolerance(VoltampereHoursInOneVoltampereHour, (double)voltamperehourQuantity.Value, VoltampereHoursTolerance);
Assert.Equal(ApparentEnergyUnit.VoltampereHour, voltamperehourQuantity.Unit);
}
public void ApparentEnergy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
{
var quantity = new ApparentEnergy(1, ApparentEnergyUnit.VoltampereHour);
QuantityInfo <ApparentEnergyUnit> quantityInfo = quantity.QuantityInfo;
Assert.Equal(ApparentEnergy.Zero, quantityInfo.Zero);
Assert.Equal("ApparentEnergy", quantityInfo.Name);
Assert.Equal(QuantityType.ApparentEnergy, quantityInfo.QuantityType);
var units = EnumUtils.GetEnumValues <ApparentEnergyUnit>().Except(new[] { ApparentEnergyUnit.Undefined }).ToArray();
var unitNames = units.Select(x => x.ToString());
// Obsolete members
Assert.Equal(units, quantityInfo.Units);
Assert.Equal(unitNames, quantityInfo.UnitNames);
}
public void EqualityOperators()
{
var a = ApparentEnergy.FromVoltampereHours(1);
var b = ApparentEnergy.FromVoltampereHours(2);
#pragma warning disable CS8073
// ReSharper disable EqualExpressionComparison
Assert.True(a == a);
Assert.False(a != a);
Assert.True(a != b);
Assert.False(a == b);
Assert.False(a == null);
Assert.False(null == a);
// ReSharper restore EqualExpressionComparison
#pragma warning restore CS8073
}
public void CompareToThrowsOnNull()
{
ApparentEnergy voltamperehour = ApparentEnergy.FromVoltampereHours(1);
Assert.Throws <ArgumentNullException>(() => voltamperehour.CompareTo(null));
}
public void CompareToThrowsOnTypeMismatch()
{
ApparentEnergy voltamperehour = ApparentEnergy.FromVoltampereHours(1);
Assert.Throws <ArgumentException>(() => voltamperehour.CompareTo(new object()));
}
public void FromVoltampereHours_WithNanValue_ThrowsArgumentException()
{
Assert.Throws <ArgumentException>(() => ApparentEnergy.FromVoltampereHours(double.NaN));
}
public void FromValueAndUnit()
{
AssertEx.EqualTolerance(1, ApparentEnergy.From(1, ApparentEnergyUnit.KilovoltampereHour).KilovoltampereHours, KilovoltampereHoursTolerance);
AssertEx.EqualTolerance(1, ApparentEnergy.From(1, ApparentEnergyUnit.MegavoltampereHour).MegavoltampereHours, MegavoltampereHoursTolerance);
AssertEx.EqualTolerance(1, ApparentEnergy.From(1, ApparentEnergyUnit.VoltampereHour).VoltampereHours, VoltampereHoursTolerance);
}
/// <inheritdoc cref="ApparentEnergy.FromKilovoltampereHours(double?)"/> public static ApparentEnergy?KilovoltampereHours(this decimal?value) => ApparentEnergy.FromKilovoltampereHours(value == null ? (double?)null : Convert.ToDouble(value.Value));
public void EqualsReturnsFalseOnTypeMismatch()
{
ApparentEnergy voltamperehour = ApparentEnergy.FromVoltampereHours(1);
Assert.False(voltamperehour.Equals(new object()));
}
public void EqualsReturnsFalseOnNull()
{
ApparentEnergy voltamperehour = ApparentEnergy.FromVoltampereHours(1);
Assert.False(voltamperehour.Equals(null));
}
/// <inheritdoc cref="ApparentEnergy.FromMegavoltampereHours(double)"/> public static ApparentEnergy MegavoltampereHours(this long value) => ApparentEnergy.FromMegavoltampereHours(value);
public void FromVoltampereHours_WithInfinityValue_ThrowsArgumentException()
{
Assert.Throws <ArgumentException>(() => ApparentEnergy.FromVoltampereHours(double.PositiveInfinity));
Assert.Throws <ArgumentException>(() => ApparentEnergy.FromVoltampereHours(double.NegativeInfinity));
}
/// <inheritdoc cref="ApparentEnergy.FromMegavoltampereHours(double?)"/> public static ApparentEnergy?MegavoltampereHours(this double?value) => ApparentEnergy.FromMegavoltampereHours(value);
