public void ArithmeticOperators()
{
Capacitance v = Capacitance.FromFarads(1);
AssertEx.EqualTolerance(-1, -v.Farads, FaradsTolerance);
AssertEx.EqualTolerance(2, (Capacitance.FromFarads(3) - v).Farads, FaradsTolerance);
AssertEx.EqualTolerance(2, (v + v).Farads, FaradsTolerance);
AssertEx.EqualTolerance(10, (v * 10).Farads, FaradsTolerance);
AssertEx.EqualTolerance(10, (10 * v).Farads, FaradsTolerance);
AssertEx.EqualTolerance(2, (Capacitance.FromFarads(10) / 5).Farads, FaradsTolerance);
AssertEx.EqualTolerance(2, Capacitance.FromFarads(10) / Capacitance.FromFarads(5), FaradsTolerance);
}
public void ConversionRoundTrip()
{
Capacitance farad = Capacitance.FromFarads(1);
AssertEx.EqualTolerance(1, Capacitance.FromFarads(farad.Farads).Farads, FaradsTolerance);
AssertEx.EqualTolerance(1, Capacitance.FromKilofarads(farad.Kilofarads).Farads, KilofaradsTolerance);
AssertEx.EqualTolerance(1, Capacitance.FromMegafarads(farad.Megafarads).Farads, MegafaradsTolerance);
AssertEx.EqualTolerance(1, Capacitance.FromMicrofarads(farad.Microfarads).Farads, MicrofaradsTolerance);
AssertEx.EqualTolerance(1, Capacitance.FromMillifarads(farad.Millifarads).Farads, MillifaradsTolerance);
AssertEx.EqualTolerance(1, Capacitance.FromNanofarads(farad.Nanofarads).Farads, NanofaradsTolerance);
AssertEx.EqualTolerance(1, Capacitance.FromPicofarads(farad.Picofarads).Farads, PicofaradsTolerance);
}
public void As()
{
var farad = Capacitance.FromFarads(1);
AssertEx.EqualTolerance(FaradsInOneFarad, farad.As(CapacitanceUnit.Farad), FaradsTolerance);
AssertEx.EqualTolerance(KilofaradsInOneFarad, farad.As(CapacitanceUnit.Kilofarad), KilofaradsTolerance);
AssertEx.EqualTolerance(MegafaradsInOneFarad, farad.As(CapacitanceUnit.Megafarad), MegafaradsTolerance);
AssertEx.EqualTolerance(MicrofaradsInOneFarad, farad.As(CapacitanceUnit.Microfarad), MicrofaradsTolerance);
AssertEx.EqualTolerance(MillifaradsInOneFarad, farad.As(CapacitanceUnit.Millifarad), MillifaradsTolerance);
AssertEx.EqualTolerance(NanofaradsInOneFarad, farad.As(CapacitanceUnit.Nanofarad), NanofaradsTolerance);
AssertEx.EqualTolerance(PicofaradsInOneFarad, farad.As(CapacitanceUnit.Picofarad), PicofaradsTolerance);
}
public void FaradToCapacitanceUnits()
{
Capacitance farad = Capacitance.FromFarads(1);
AssertEx.EqualTolerance(FaradsInOneFarad, farad.Farads, FaradsTolerance);
AssertEx.EqualTolerance(KilofaradsInOneFarad, farad.Kilofarads, KilofaradsTolerance);
AssertEx.EqualTolerance(MegafaradsInOneFarad, farad.Megafarads, MegafaradsTolerance);
AssertEx.EqualTolerance(MicrofaradsInOneFarad, farad.Microfarads, MicrofaradsTolerance);
AssertEx.EqualTolerance(MillifaradsInOneFarad, farad.Millifarads, MillifaradsTolerance);
AssertEx.EqualTolerance(NanofaradsInOneFarad, farad.Nanofarads, NanofaradsTolerance);
AssertEx.EqualTolerance(PicofaradsInOneFarad, farad.Picofarads, PicofaradsTolerance);
}
public void EqualityOperators()
{
Capacitance a = Capacitance.FromFarads(1);
Capacitance b = Capacitance.FromFarads(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 As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
{
var quantity = new Capacitance(value: 1, unit: Capacitance.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 ComparisonOperators()
{
Capacitance oneFarad = Capacitance.FromFarads(1);
Capacitance twoFarads = Capacitance.FromFarads(2);
Assert.True(oneFarad < twoFarads);
Assert.True(oneFarad <= twoFarads);
Assert.True(twoFarads > oneFarad);
Assert.True(twoFarads >= oneFarad);
Assert.False(oneFarad > twoFarads);
Assert.False(oneFarad >= twoFarads);
Assert.False(twoFarads < oneFarad);
Assert.False(twoFarads <= oneFarad);
}
public void Capacitance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
{
var quantity = new Capacitance(1, CapacitanceUnit.Farad);
QuantityInfo <CapacitanceUnit> quantityInfo = quantity.QuantityInfo;
Assert.Equal(Capacitance.Zero, quantityInfo.Zero);
Assert.Equal("Capacitance", quantityInfo.Name);
Assert.Equal(QuantityType.Capacitance, quantityInfo.QuantityType);
var units = EnumUtils.GetEnumValues <CapacitanceUnit>().Except(new[] { CapacitanceUnit.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 = Capacitance.FromFarads(1);
var b = Capacitance.FromFarads(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 ToUnit()
{
var farad = Capacitance.FromFarads(1);
var faradQuantity = farad.ToUnit(CapacitanceUnit.Farad);
AssertEx.EqualTolerance(FaradsInOneFarad, (double)faradQuantity.Value, FaradsTolerance);
Assert.Equal(CapacitanceUnit.Farad, faradQuantity.Unit);
var kilofaradQuantity = farad.ToUnit(CapacitanceUnit.Kilofarad);
AssertEx.EqualTolerance(KilofaradsInOneFarad, (double)kilofaradQuantity.Value, KilofaradsTolerance);
Assert.Equal(CapacitanceUnit.Kilofarad, kilofaradQuantity.Unit);
var megafaradQuantity = farad.ToUnit(CapacitanceUnit.Megafarad);
AssertEx.EqualTolerance(MegafaradsInOneFarad, (double)megafaradQuantity.Value, MegafaradsTolerance);
Assert.Equal(CapacitanceUnit.Megafarad, megafaradQuantity.Unit);
var microfaradQuantity = farad.ToUnit(CapacitanceUnit.Microfarad);
AssertEx.EqualTolerance(MicrofaradsInOneFarad, (double)microfaradQuantity.Value, MicrofaradsTolerance);
Assert.Equal(CapacitanceUnit.Microfarad, microfaradQuantity.Unit);
var millifaradQuantity = farad.ToUnit(CapacitanceUnit.Millifarad);
AssertEx.EqualTolerance(MillifaradsInOneFarad, (double)millifaradQuantity.Value, MillifaradsTolerance);
Assert.Equal(CapacitanceUnit.Millifarad, millifaradQuantity.Unit);
var nanofaradQuantity = farad.ToUnit(CapacitanceUnit.Nanofarad);
AssertEx.EqualTolerance(NanofaradsInOneFarad, (double)nanofaradQuantity.Value, NanofaradsTolerance);
Assert.Equal(CapacitanceUnit.Nanofarad, nanofaradQuantity.Unit);
var picofaradQuantity = farad.ToUnit(CapacitanceUnit.Picofarad);
AssertEx.EqualTolerance(PicofaradsInOneFarad, (double)picofaradQuantity.Value, PicofaradsTolerance);
Assert.Equal(CapacitanceUnit.Picofarad, picofaradQuantity.Unit);
}
public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
{
var quantity00 = Capacitance.From(1, CapacitanceUnit.Farad);
AssertEx.EqualTolerance(1, quantity00.Farads, FaradsTolerance);
Assert.Equal(CapacitanceUnit.Farad, quantity00.Unit);
var quantity01 = Capacitance.From(1, CapacitanceUnit.Kilofarad);
AssertEx.EqualTolerance(1, quantity01.Kilofarads, KilofaradsTolerance);
Assert.Equal(CapacitanceUnit.Kilofarad, quantity01.Unit);
var quantity02 = Capacitance.From(1, CapacitanceUnit.Megafarad);
AssertEx.EqualTolerance(1, quantity02.Megafarads, MegafaradsTolerance);
Assert.Equal(CapacitanceUnit.Megafarad, quantity02.Unit);
var quantity03 = Capacitance.From(1, CapacitanceUnit.Microfarad);
AssertEx.EqualTolerance(1, quantity03.Microfarads, MicrofaradsTolerance);
Assert.Equal(CapacitanceUnit.Microfarad, quantity03.Unit);
var quantity04 = Capacitance.From(1, CapacitanceUnit.Millifarad);
AssertEx.EqualTolerance(1, quantity04.Millifarads, MillifaradsTolerance);
Assert.Equal(CapacitanceUnit.Millifarad, quantity04.Unit);
var quantity05 = Capacitance.From(1, CapacitanceUnit.Nanofarad);
AssertEx.EqualTolerance(1, quantity05.Nanofarads, NanofaradsTolerance);
Assert.Equal(CapacitanceUnit.Nanofarad, quantity05.Unit);
var quantity06 = Capacitance.From(1, CapacitanceUnit.Picofarad);
AssertEx.EqualTolerance(1, quantity06.Picofarads, PicofaradsTolerance);
Assert.Equal(CapacitanceUnit.Picofarad, quantity06.Unit);
}
public void ConversionRoundTrip()
{
Capacitance farad = Capacitance.FromFarads(1);
AssertEx.EqualTolerance(1, Capacitance.FromFarads(farad.Farads).Farads, FaradsTolerance);
}
public void As()
{
var farad = Capacitance.FromFarads(1);
AssertEx.EqualTolerance(FaradsInOneFarad, farad.As(CapacitanceUnit.Farad), FaradsTolerance);
}
public void FromValueAndUnit()
{
AssertEx.EqualTolerance(1, Capacitance.From(1, CapacitanceUnit.Farad).Farads, FaradsTolerance);
}
public void FaradToCapacitanceUnits()
{
Capacitance farad = Capacitance.FromFarads(1);
AssertEx.EqualTolerance(FaradsInOneFarad, farad.Farads, FaradsTolerance);
}
public void EqualsReturnsFalseOnTypeMismatch()
{
Capacitance farad = Capacitance.FromFarads(1);
Assert.False(farad.Equals(new object()));
}
public void CompareToThrowsOnTypeMismatch()
{
Capacitance farad = Capacitance.FromFarads(1);
Assert.Throws <ArgumentException>(() => farad.CompareTo(new object()));
}
public void NumberToKilofaradsTest() => Assert.Equal(Capacitance.FromKilofarads(2), 2.Kilofarads());
public void NumberToFaradsTest() => Assert.Equal(Capacitance.FromFarads(2), 2.Farads());
/// <inheritdoc cref="Capacitance.FromFarads(double?)"/> public static Capacitance?Farads(this decimal?value) => Capacitance.FromFarads(value == null ? (double?)null : Convert.ToDouble(value.Value));
/// <inheritdoc cref="Capacitance.FromFarads(double)"/> public static Capacitance Farads(this decimal value) => Capacitance.FromFarads(Convert.ToDouble(value));
public void FromFarads_WithInfinityValue_ThrowsArgumentException()
{
Assert.Throws <ArgumentException>(() => Capacitance.FromFarads(double.PositiveInfinity));
Assert.Throws <ArgumentException>(() => Capacitance.FromFarads(double.NegativeInfinity));
}
public void FromFarads_WithNanValue_ThrowsArgumentException()
{
Assert.Throws <ArgumentException>(() => Capacitance.FromFarads(double.NaN));
}
/// <inheritdoc cref="Capacitance.FromNanofarads(UnitsNet.QuantityValue)" /> public static Capacitance Nanofarads <T>(this T value) => Capacitance.FromNanofarads(Convert.ToDouble(value));
public void NumberToMillifaradsTest() => Assert.Equal(Capacitance.FromMillifarads(2), 2.Millifarads());
protected void SetScalarValue(DependencyProperty property, Capacitance? 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 CompareToThrowsOnNull()
{
Capacitance farad = Capacitance.FromFarads(1);
Assert.Throws <ArgumentNullException>(() => farad.CompareTo(null));
}
public void NumberToNanofaradsTest() => Assert.Equal(Capacitance.FromNanofarads(2), 2.Nanofarads());
public void EqualsReturnsFalseOnNull()
{
Capacitance farad = Capacitance.FromFarads(1);
Assert.False(farad.Equals(null));
}
public void NumberToPicofaradsTest() => Assert.Equal(Capacitance.FromPicofarads(2), 2.Picofarads());
public static Capacitance Picofarads <T>(this T value) => Capacitance.FromPicofarads(Convert.ToDecimal(value));
protected virtual void OnMaxValueChanged(Capacitance? oldValue, Capacitance? newValue)
{
this.SetScalarValue(ScalarMaxValueProperty, newValue);
}
