public void EqualsRelativeToleranceIsImplemented() { var v = MagneticFlux.FromWebers(1); Assert.True(v.Equals(MagneticFlux.FromWebers(1), WebersTolerance, ComparisonType.Relative)); Assert.False(v.Equals(MagneticFlux.Zero, WebersTolerance, ComparisonType.Relative)); }
public void EqualsIsImplemented() { MagneticFlux v = MagneticFlux.FromWebers(1); Assert.True(v.Equals(MagneticFlux.FromWebers(1), MagneticFlux.FromWebers(WebersTolerance))); Assert.False(v.Equals(MagneticFlux.Zero, MagneticFlux.FromWebers(WebersTolerance))); }
public void FromWebers_WithInfinityValue_CreateQuantityAndAffectInfinityValue() { var positiveInfinityQuantity = MagneticFlux.FromWebers(double.PositiveInfinity); var negativeInfinityQuantity = MagneticFlux.FromWebers(double.NegativeInfinity); Assert.True(double.IsPositiveInfinity(positiveInfinityQuantity.Value)); Assert.True(double.IsNegativeInfinity(negativeInfinityQuantity.Value)); }
public void CompareToIsImplemented() { MagneticFlux weber = MagneticFlux.FromWebers(1); Assert.Equal(0, weber.CompareTo(weber)); Assert.True(weber.CompareTo(MagneticFlux.Zero) > 0); Assert.True(MagneticFlux.Zero.CompareTo(weber) < 0); }
public void Equals_SameType_IsImplemented() { var a = MagneticFlux.FromWebers(1); var b = MagneticFlux.FromWebers(2); Assert.True(a.Equals(a)); Assert.False(a.Equals(b)); }
public void ToUnit() { var weber = MagneticFlux.FromWebers(1); var weberQuantity = weber.ToUnit(MagneticFluxUnit.Weber); AssertEx.EqualTolerance(WebersInOneWeber, (double)weberQuantity.Value, WebersTolerance); Assert.Equal(MagneticFluxUnit.Weber, weberQuantity.Unit); }
public void Equals_QuantityAsObject_IsImplemented() { object a = MagneticFlux.FromWebers(1); object b = MagneticFlux.FromWebers(2); Assert.True(a.Equals(a)); Assert.False(a.Equals(b)); Assert.False(a.Equals((object)null)); }
public void ArithmeticOperators() { MagneticFlux v = MagneticFlux.FromWebers(1); AssertEx.EqualTolerance(-1, -v.Webers, WebersTolerance); AssertEx.EqualTolerance(2, (MagneticFlux.FromWebers(3) - v).Webers, WebersTolerance); AssertEx.EqualTolerance(2, (v + v).Webers, WebersTolerance); AssertEx.EqualTolerance(10, (v * 10).Webers, WebersTolerance); AssertEx.EqualTolerance(10, (10 * v).Webers, WebersTolerance); AssertEx.EqualTolerance(2, (MagneticFlux.FromWebers(10) / 5).Webers, WebersTolerance); AssertEx.EqualTolerance(2, MagneticFlux.FromWebers(10) / MagneticFlux.FromWebers(5), WebersTolerance); }
public void To_UnitSystem_ThrowsArgumentExceptionIfNotSupported() { var weber = MagneticFlux.FromWebers(1); Assert.Throws <ArgumentException>(() => weber.ToUnit(UnitSystem.SI)); Assert.Throws <ArgumentException>(() => weber.ToUnit(UnitSystem.CGS)); Assert.Throws <ArgumentException>(() => weber.ToUnit(UnitSystem.BI)); Assert.Throws <ArgumentException>(() => weber.ToUnit(UnitSystem.EE)); Assert.Throws <ArgumentException>(() => weber.ToUnit(UnitSystem.USC)); Assert.Throws <ArgumentException>(() => weber.ToUnit(UnitSystem.FPS)); Assert.Throws <ArgumentException>(() => weber.ToUnit(UnitSystem.Astronomical)); }
public void EqualityOperators() { MagneticFlux a = MagneticFlux.FromWebers(1); MagneticFlux b = MagneticFlux.FromWebers(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() { MagneticFlux oneWeber = MagneticFlux.FromWebers(1); MagneticFlux twoWebers = MagneticFlux.FromWebers(2); Assert.True(oneWeber < twoWebers); Assert.True(oneWeber <= twoWebers); Assert.True(twoWebers > oneWeber); Assert.True(twoWebers >= oneWeber); Assert.False(oneWeber > twoWebers); Assert.False(oneWeber >= twoWebers); Assert.False(twoWebers < oneWeber); Assert.False(twoWebers <= oneWeber); }
public void EqualityOperators() { var a = MagneticFlux.FromWebers(1); var b = MagneticFlux.FromWebers(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 Convert_ToUInt64_EqualsValueAsSameType() { var quantity = MagneticFlux.FromWebers(1.0); Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity)); }
public void CompareToThrowsOnTypeMismatch() { MagneticFlux weber = MagneticFlux.FromWebers(1); Assert.Throws <ArgumentException>(() => weber.CompareTo(new object())); }
public void CompareToThrowsOnNull() { MagneticFlux weber = MagneticFlux.FromWebers(1); Assert.Throws <ArgumentNullException>(() => weber.CompareTo(null)); }
public void Convert_ChangeType_UnitType_EqualsUnit() { var quantity = MagneticFlux.FromWebers(1.0); Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(MagneticFluxUnit))); }
public void Convert_ChangeType_SelfType_EqualsSelf() { var quantity = MagneticFlux.FromWebers(1.0); Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(MagneticFlux))); }
public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value) { var quantity = MagneticFlux.FromWebers(value); Assert.Equal(MagneticFlux.FromWebers(-value), -quantity); }
public void Convert_ChangeType_QuantityType_EqualsQuantityType() { var quantity = MagneticFlux.FromWebers(1.0); Assert.Equal(QuantityType.MagneticFlux, Convert.ChangeType(quantity, typeof(QuantityType))); }
public void As() { var weber = MagneticFlux.FromWebers(1); AssertEx.EqualTolerance(WebersInOneWeber, weber.As(MagneticFluxUnit.Weber), WebersTolerance); }
public void Convert_ChangeType_QuantityInfo_EqualsQuantityInfo() { var quantity = MagneticFlux.FromWebers(1.0); Assert.Equal(MagneticFlux.Info, Convert.ChangeType(quantity, typeof(QuantityInfo))); }
public void FromWebers_WithInfinityValue_ThrowsArgumentException() { Assert.Throws <ArgumentException>(() => MagneticFlux.FromWebers(double.PositiveInfinity)); Assert.Throws <ArgumentException>(() => MagneticFlux.FromWebers(double.NegativeInfinity)); }
public void FromWebers_WithNanValue_ThrowsArgumentException() { Assert.Throws <ArgumentException>(() => MagneticFlux.FromWebers(double.NaN)); }
public void WeberToMagneticFluxUnits() { MagneticFlux weber = MagneticFlux.FromWebers(1); AssertEx.EqualTolerance(WebersInOneWeber, weber.Webers, WebersTolerance); }
public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions() { var quantity = MagneticFlux.FromWebers(1.0); Assert.Equal(MagneticFlux.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions))); }
public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException() { var quantity = MagneticFlux.FromWebers(1.0); Assert.Throws <InvalidCastException>(() => Convert.ChangeType(quantity, typeof(QuantityFormatter))); }
public void EqualsReturnsFalseOnTypeMismatch() { MagneticFlux weber = MagneticFlux.FromWebers(1); Assert.False(weber.Equals(new object())); }
public void ConversionRoundTrip() { MagneticFlux weber = MagneticFlux.FromWebers(1); AssertEx.EqualTolerance(1, MagneticFlux.FromWebers(weber.Webers).Webers, WebersTolerance); }
public void EqualsReturnsFalseOnNull() { MagneticFlux weber = MagneticFlux.FromWebers(1); Assert.False(weber.Equals(null)); }
public void GetHashCode_Equals() { var quantity = MagneticFlux.FromWebers(1.0); Assert.Equal(new { MagneticFlux.Info.Name, quantity.Value, quantity.Unit }.GetHashCode(), quantity.GetHashCode()); }