/// <inheritdoc cref="SolidAngle.FromSteradians(double)"/> public static SolidAngle Steradians(this decimal value) => SolidAngle.FromSteradians(Convert.ToDouble(value));
public void ConversionRoundTrip() { SolidAngle steradian = SolidAngle.FromSteradians(1); AssertEx.EqualTolerance(1, SolidAngle.FromSteradians(steradian.Steradians).Steradians, SteradiansTolerance); }
/// <inheritdoc cref="SolidAngle.FromSteradians(double)"/> public static SolidAngle Steradians(this double value) => SolidAngle.FromSteradians(value);
public void EqualsReturnsFalseOnNull() { SolidAngle steradian = SolidAngle.FromSteradians(1); Assert.False(steradian.Equals(null)); }
public void FromValueAndUnit() { AssertEx.EqualTolerance(1, SolidAngle.From(1, SolidAngleUnit.Steradian).Steradians, SteradiansTolerance); }
/// <inheritdoc cref="SolidAngle.FromSteradians(UnitsNet.QuantityValue)" /> public static SolidAngle Steradians <T>(this T value) => SolidAngle.FromSteradians(Convert.ToDouble(value));
public void CompareToThrowsOnNull() { SolidAngle steradian = SolidAngle.FromSteradians(1); Assert.Throws <ArgumentNullException>(() => steradian.CompareTo(null)); }
public void Convert_ToUInt64_EqualsValueAsSameType() { var quantity = SolidAngle.FromSteradians(1.0); Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity)); }
public void Convert_ChangeType_SelfType_EqualsSelf() { var quantity = SolidAngle.FromSteradians(1.0); Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(SolidAngle))); }
public void Convert_ToSingle_EqualsValueAsSameType() { var quantity = SolidAngle.FromSteradians(1.0); Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity)); }
public void Convert_ToString_EqualsToString() { var quantity = SolidAngle.FromSteradians(1.0); Assert.Equal(quantity.ToString(), Convert.ToString(quantity)); }
public void Convert_ToInt16_EqualsValueAsSameType() { var quantity = SolidAngle.FromSteradians(1.0); Assert.Equal((short)quantity.Value, Convert.ToInt16(quantity)); }
public void Convert_ToDecimal_EqualsValueAsSameType() { var quantity = SolidAngle.FromSteradians(1.0); Assert.Equal((decimal)quantity.Value, Convert.ToDecimal(quantity)); }
public void Convert_ToDateTime_ThrowsInvalidCastException() { var quantity = SolidAngle.FromSteradians(1.0); Assert.Throws <InvalidCastException>(() => Convert.ToDateTime(quantity)); }
protected void SetScalarValue(DependencyProperty property, SolidAngle? 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 Convert_ChangeType_UnitType_EqualsUnit() { var quantity = SolidAngle.FromSteradians(1.0); Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(SolidAngleUnit))); }
public void NumberToSteradiansTest() => Assert.Equal(SolidAngle.FromSteradians(2), 2.Steradians());
public void Convert_ChangeType_QuantityType_EqualsQuantityType() { var quantity = SolidAngle.FromSteradians(1.0); Assert.Equal(QuantityType.SolidAngle, Convert.ChangeType(quantity, typeof(QuantityType))); }
public void CompareToThrowsOnTypeMismatch() { SolidAngle steradian = SolidAngle.FromSteradians(1); Assert.Throws <ArgumentException>(() => steradian.CompareTo(new object())); }
public void Convert_ChangeType_QuantityInfo_EqualsQuantityInfo() { var quantity = SolidAngle.FromSteradians(1.0); Assert.Equal(SolidAngle.Info, Convert.ChangeType(quantity, typeof(QuantityInfo))); }
public void EqualsReturnsFalseOnTypeMismatch() { SolidAngle steradian = SolidAngle.FromSteradians(1); Assert.False(steradian.Equals(new object())); }
public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions() { var quantity = SolidAngle.FromSteradians(1.0); Assert.Equal(SolidAngle.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions))); }
public void SteradianToSolidAngleUnits() { SolidAngle steradian = SolidAngle.FromSteradians(1); AssertEx.EqualTolerance(SteradiansInOneSteradian, steradian.Steradians, SteradiansTolerance); }
public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException() { var quantity = SolidAngle.FromSteradians(1.0); Assert.Throws <InvalidCastException>(() => Convert.ChangeType(quantity, typeof(QuantityFormatter))); }
public void As() { var steradian = SolidAngle.FromSteradians(1); AssertEx.EqualTolerance(SteradiansInOneSteradian, steradian.As(SolidAngleUnit.Steradian), SteradiansTolerance); }
public void GetHashCode_Equals() { var quantity = SolidAngle.FromSteradians(1.0); Assert.Equal(new { SolidAngle.Info.Name, quantity.Value, quantity.Unit }.GetHashCode(), quantity.GetHashCode()); }
/// <inheritdoc /> public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { if (!this.initialized) { this.Initialize(); } var message = this.errorText.ToString(); if (!(targetType == typeof(SolidAngle) || targetType == typeof(SolidAngle?))) { message += $"{this.GetType().Name} does not support converting to {targetType.Name}"; } if (message != string.Empty) { message = message.TrimEnd('\r', '\n'); if (Is.DesignMode) { throw new InvalidOperationException(message); } return(message); } if (value == null) { return(null); } if (value is double) { return(new SolidAngle((double)value, this.unit.Value)); } var text = value as string; if (string.IsNullOrEmpty(text)) { return(null); } var unitInput = this.UnitInput ?? Wpf.UnitInput.ScalarOnly; switch (unitInput) { case Wpf.UnitInput.ScalarOnly: { double d; if (double.TryParse(text, NumberStyles.Float, culture, out d)) { return(new SolidAngle(d, this.unit.Value)); } SolidAngle result; if (SolidAngle.TryParse(text, NumberStyles.Float, culture, out result)) { return($"#{text}#"); // returning modified text so that TypeConverter fails and we get an error } return(text); // returning raw to trigger error } case Wpf.UnitInput.SymbolAllowed: { double d; int pos = 0; WhiteSpaceReader.TryRead(text, ref pos); if (DoubleReader.TryRead(text, ref pos, NumberStyles.Float, culture, out d)) { WhiteSpaceReader.TryRead(text, ref pos); if (pos == text.Length) { return(new SolidAngle(d, this.unit.Value)); } } goto case Wpf.UnitInput.SymbolRequired; } case Wpf.UnitInput.SymbolRequired: { SolidAngle result; if (SolidAngle.TryParse(text, NumberStyles.Float, culture, out result)) { return(result); } return(text); } default: throw new ArgumentOutOfRangeException(); } }
public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value) { var quantity = SolidAngle.FromSteradians(value); Assert.Equal(SolidAngle.FromSteradians(-value), -quantity); }
/// <inheritdoc cref="SolidAngle.FromSteradians(double?)"/> public static SolidAngle?Steradians(this float?value) => SolidAngle.FromSteradians(value);
public static SolidAngle?Steradians <T>(this T?value) where T : struct => SolidAngle.FromSteradians(value == null ? (double?)null : Convert.ToDouble(value.Value));
/// <inheritdoc cref="SolidAngle.FromSteradians(double?)"/> public static SolidAngle?Steradians(this decimal?value) => SolidAngle.FromSteradians(value == null ? (double?)null : Convert.ToDouble(value.Value));
protected virtual void OnMaxValueChanged(SolidAngle? oldValue, SolidAngle? newValue) { this.SetScalarValue(ScalarMaxValueProperty, newValue); }