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