public void Equals_RelativeTolerance_IsImplemented()
{
var v = ReciprocalArea.FromInverseSquareMeters(1);
Assert.True(v.Equals(ReciprocalArea.FromInverseSquareMeters(1), InverseSquareMetersTolerance, ComparisonType.Relative));
Assert.False(v.Equals(ReciprocalArea.Zero, InverseSquareMetersTolerance, ComparisonType.Relative));
}
public void ToUnit()
{
var inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1);
var inversesquarecentimeterQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareCentimeter);
AssertEx.EqualTolerance(InverseSquareCentimetersInOneInverseSquareMeter, (double)inversesquarecentimeterQuantity.Value, InverseSquareCentimetersTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareCentimeter, inversesquarecentimeterQuantity.Unit);
var inversesquaredecimeterQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareDecimeter);
AssertEx.EqualTolerance(InverseSquareDecimetersInOneInverseSquareMeter, (double)inversesquaredecimeterQuantity.Value, InverseSquareDecimetersTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareDecimeter, inversesquaredecimeterQuantity.Unit);
var inversesquarefootQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareFoot);
AssertEx.EqualTolerance(InverseSquareFeetInOneInverseSquareMeter, (double)inversesquarefootQuantity.Value, InverseSquareFeetTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareFoot, inversesquarefootQuantity.Unit);
var inversesquareinchQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareInch);
AssertEx.EqualTolerance(InverseSquareInchesInOneInverseSquareMeter, (double)inversesquareinchQuantity.Value, InverseSquareInchesTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareInch, inversesquareinchQuantity.Unit);
var inversesquarekilometerQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareKilometer);
AssertEx.EqualTolerance(InverseSquareKilometersInOneInverseSquareMeter, (double)inversesquarekilometerQuantity.Value, InverseSquareKilometersTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareKilometer, inversesquarekilometerQuantity.Unit);
var inversesquaremeterQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareMeter);
AssertEx.EqualTolerance(InverseSquareMetersInOneInverseSquareMeter, (double)inversesquaremeterQuantity.Value, InverseSquareMetersTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareMeter, inversesquaremeterQuantity.Unit);
var inversesquaremicrometerQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareMicrometer);
AssertEx.EqualTolerance(InverseSquareMicrometersInOneInverseSquareMeter, (double)inversesquaremicrometerQuantity.Value, InverseSquareMicrometersTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareMicrometer, inversesquaremicrometerQuantity.Unit);
var inversesquaremileQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareMile);
AssertEx.EqualTolerance(InverseSquareMilesInOneInverseSquareMeter, (double)inversesquaremileQuantity.Value, InverseSquareMilesTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareMile, inversesquaremileQuantity.Unit);
var inversesquaremillimeterQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareMillimeter);
AssertEx.EqualTolerance(InverseSquareMillimetersInOneInverseSquareMeter, (double)inversesquaremillimeterQuantity.Value, InverseSquareMillimetersTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareMillimeter, inversesquaremillimeterQuantity.Unit);
var inversesquareyardQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareYard);
AssertEx.EqualTolerance(InverseSquareYardsInOneInverseSquareMeter, (double)inversesquareyardQuantity.Value, InverseSquareYardsTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareYard, inversesquareyardQuantity.Unit);
var inverseussurveysquarefootQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseUsSurveySquareFoot);
AssertEx.EqualTolerance(InverseUsSurveySquareFeetInOneInverseSquareMeter, (double)inverseussurveysquarefootQuantity.Value, InverseUsSurveySquareFeetTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseUsSurveySquareFoot, inverseussurveysquarefootQuantity.Unit);
}
public void CompareToIsImplemented()
{
ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1);
Assert.Equal(0, inversesquaremeter.CompareTo(inversesquaremeter));
Assert.True(inversesquaremeter.CompareTo(ReciprocalArea.Zero) > 0);
Assert.True(ReciprocalArea.Zero.CompareTo(inversesquaremeter) < 0);
}
public void Equals_SameType_IsImplemented()
{
var a = ReciprocalArea.FromInverseSquareMeters(1);
var b = ReciprocalArea.FromInverseSquareMeters(2);
Assert.True(a.Equals(a));
Assert.False(a.Equals(b));
}
public void Equals_QuantityAsObject_IsImplemented()
{
object a = ReciprocalArea.FromInverseSquareMeters(1);
object b = ReciprocalArea.FromInverseSquareMeters(2);
Assert.True(a.Equals(a));
Assert.False(a.Equals(b));
Assert.False(a.Equals((object)null));
}
public void ArithmeticOperators()
{
ReciprocalArea v = ReciprocalArea.FromInverseSquareMeters(1);
AssertEx.EqualTolerance(-1, -v.InverseSquareMeters, InverseSquareMetersTolerance);
AssertEx.EqualTolerance(2, (ReciprocalArea.FromInverseSquareMeters(3) - v).InverseSquareMeters, InverseSquareMetersTolerance);
AssertEx.EqualTolerance(2, (v + v).InverseSquareMeters, InverseSquareMetersTolerance);
AssertEx.EqualTolerance(10, (v * 10).InverseSquareMeters, InverseSquareMetersTolerance);
AssertEx.EqualTolerance(10, (10 * v).InverseSquareMeters, InverseSquareMetersTolerance);
AssertEx.EqualTolerance(2, (ReciprocalArea.FromInverseSquareMeters(10) / 5).InverseSquareMeters, InverseSquareMetersTolerance);
AssertEx.EqualTolerance(2, ReciprocalArea.FromInverseSquareMeters(10) / ReciprocalArea.FromInverseSquareMeters(5), InverseSquareMetersTolerance);
}
public void ComparisonOperators()
{
ReciprocalArea oneInverseSquareMeter = ReciprocalArea.FromInverseSquareMeters(1);
ReciprocalArea twoInverseSquareMeters = ReciprocalArea.FromInverseSquareMeters(2);
Assert.True(oneInverseSquareMeter < twoInverseSquareMeters);
Assert.True(oneInverseSquareMeter <= twoInverseSquareMeters);
Assert.True(twoInverseSquareMeters > oneInverseSquareMeter);
Assert.True(twoInverseSquareMeters >= oneInverseSquareMeter);
Assert.False(oneInverseSquareMeter > twoInverseSquareMeters);
Assert.False(oneInverseSquareMeter >= twoInverseSquareMeters);
Assert.False(twoInverseSquareMeters < oneInverseSquareMeter);
Assert.False(twoInverseSquareMeters <= oneInverseSquareMeter);
}
public void ConversionRoundTrip()
{
ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1);
AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareCentimeters(inversesquaremeter.InverseSquareCentimeters).InverseSquareMeters, InverseSquareCentimetersTolerance);
AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareDecimeters(inversesquaremeter.InverseSquareDecimeters).InverseSquareMeters, InverseSquareDecimetersTolerance);
AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareFeet(inversesquaremeter.InverseSquareFeet).InverseSquareMeters, InverseSquareFeetTolerance);
AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareInches(inversesquaremeter.InverseSquareInches).InverseSquareMeters, InverseSquareInchesTolerance);
AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareKilometers(inversesquaremeter.InverseSquareKilometers).InverseSquareMeters, InverseSquareKilometersTolerance);
AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareMeters(inversesquaremeter.InverseSquareMeters).InverseSquareMeters, InverseSquareMetersTolerance);
AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareMicrometers(inversesquaremeter.InverseSquareMicrometers).InverseSquareMeters, InverseSquareMicrometersTolerance);
AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareMiles(inversesquaremeter.InverseSquareMiles).InverseSquareMeters, InverseSquareMilesTolerance);
AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareMillimeters(inversesquaremeter.InverseSquareMillimeters).InverseSquareMeters, InverseSquareMillimetersTolerance);
AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareYards(inversesquaremeter.InverseSquareYards).InverseSquareMeters, InverseSquareYardsTolerance);
AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseUsSurveySquareFeet(inversesquaremeter.InverseUsSurveySquareFeet).InverseSquareMeters, InverseUsSurveySquareFeetTolerance);
}
public void InverseSquareMeterToReciprocalAreaUnits()
{
ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1);
AssertEx.EqualTolerance(InverseSquareCentimetersInOneInverseSquareMeter, inversesquaremeter.InverseSquareCentimeters, InverseSquareCentimetersTolerance);
AssertEx.EqualTolerance(InverseSquareDecimetersInOneInverseSquareMeter, inversesquaremeter.InverseSquareDecimeters, InverseSquareDecimetersTolerance);
AssertEx.EqualTolerance(InverseSquareFeetInOneInverseSquareMeter, inversesquaremeter.InverseSquareFeet, InverseSquareFeetTolerance);
AssertEx.EqualTolerance(InverseSquareInchesInOneInverseSquareMeter, inversesquaremeter.InverseSquareInches, InverseSquareInchesTolerance);
AssertEx.EqualTolerance(InverseSquareKilometersInOneInverseSquareMeter, inversesquaremeter.InverseSquareKilometers, InverseSquareKilometersTolerance);
AssertEx.EqualTolerance(InverseSquareMetersInOneInverseSquareMeter, inversesquaremeter.InverseSquareMeters, InverseSquareMetersTolerance);
AssertEx.EqualTolerance(InverseSquareMicrometersInOneInverseSquareMeter, inversesquaremeter.InverseSquareMicrometers, InverseSquareMicrometersTolerance);
AssertEx.EqualTolerance(InverseSquareMilesInOneInverseSquareMeter, inversesquaremeter.InverseSquareMiles, InverseSquareMilesTolerance);
AssertEx.EqualTolerance(InverseSquareMillimetersInOneInverseSquareMeter, inversesquaremeter.InverseSquareMillimeters, InverseSquareMillimetersTolerance);
AssertEx.EqualTolerance(InverseSquareYardsInOneInverseSquareMeter, inversesquaremeter.InverseSquareYards, InverseSquareYardsTolerance);
AssertEx.EqualTolerance(InverseUsSurveySquareFeetInOneInverseSquareMeter, inversesquaremeter.InverseUsSurveySquareFeet, InverseUsSurveySquareFeetTolerance);
}
public void As()
{
var inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1);
AssertEx.EqualTolerance(InverseSquareCentimetersInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareCentimeter), InverseSquareCentimetersTolerance);
AssertEx.EqualTolerance(InverseSquareDecimetersInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareDecimeter), InverseSquareDecimetersTolerance);
AssertEx.EqualTolerance(InverseSquareFeetInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareFoot), InverseSquareFeetTolerance);
AssertEx.EqualTolerance(InverseSquareInchesInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareInch), InverseSquareInchesTolerance);
AssertEx.EqualTolerance(InverseSquareKilometersInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareKilometer), InverseSquareKilometersTolerance);
AssertEx.EqualTolerance(InverseSquareMetersInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareMeter), InverseSquareMetersTolerance);
AssertEx.EqualTolerance(InverseSquareMicrometersInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareMicrometer), InverseSquareMicrometersTolerance);
AssertEx.EqualTolerance(InverseSquareMilesInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareMile), InverseSquareMilesTolerance);
AssertEx.EqualTolerance(InverseSquareMillimetersInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareMillimeter), InverseSquareMillimetersTolerance);
AssertEx.EqualTolerance(InverseSquareYardsInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareYard), InverseSquareYardsTolerance);
AssertEx.EqualTolerance(InverseUsSurveySquareFeetInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseUsSurveySquareFoot), InverseUsSurveySquareFeetTolerance);
}
public void EqualityOperators()
{
var a = ReciprocalArea.FromInverseSquareMeters(1);
var b = ReciprocalArea.FromInverseSquareMeters(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_ToString_EqualsToString()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal(quantity.ToString(), Convert.ToString(quantity));
}
public void Convert_ToSingle_EqualsValueAsSameType()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity));
}
public void Convert_ToInt16_EqualsValueAsSameType()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal((short)quantity.Value, Convert.ToInt16(quantity));
}
public void Convert_ToDecimal_EqualsValueAsSameType()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal((decimal)quantity.Value, Convert.ToDecimal(quantity));
}
public void Convert_ToDateTime_ThrowsInvalidCastException()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Throws <InvalidCastException>(() => Convert.ToDateTime(quantity));
}
public void ToString_NullProvider_EqualsCurrentUICulture()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal(quantity.ToString(CultureInfo.CurrentUICulture, "g"), quantity.ToString(null, "g"));
}
public void GetHashCode_Equals()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal(new { ReciprocalArea.Info.Name, quantity.Value, quantity.Unit }.GetHashCode(), quantity.GetHashCode());
}
public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal(ReciprocalArea.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions)));
}
public void Convert_ChangeType_UnitType_EqualsUnit()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(ReciprocalAreaUnit)));
}
public void Convert_ToUInt64_EqualsValueAsSameType()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity));
}
public void CompareToThrowsOnNull()
{
ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1);
Assert.Throws <ArgumentNullException>(() => inversesquaremeter.CompareTo(null));
}
public void Convert_ChangeType_SelfType_EqualsSelf()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(ReciprocalArea)));
}
public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
{
var v = ReciprocalArea.FromInverseSquareMeters(1);
Assert.Throws <ArgumentOutOfRangeException>(() => v.Equals(ReciprocalArea.FromInverseSquareMeters(1), -1, ComparisonType.Relative));
}
public void Convert_ChangeType_QuantityInfo_EqualsQuantityInfo()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal(ReciprocalArea.Info, Convert.ChangeType(quantity, typeof(QuantityInfo)));
}
public void EqualsReturnsFalseOnTypeMismatch()
{
ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1);
Assert.False(inversesquaremeter.Equals(new object()));
}
public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Throws <InvalidCastException>(() => Convert.ChangeType(quantity, typeof(QuantityFormatter)));
}
public void EqualsReturnsFalseOnNull()
{
ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1);
Assert.False(inversesquaremeter.Equals(null));
}
public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value)
{
var quantity = ReciprocalArea.FromInverseSquareMeters(value);
Assert.Equal(ReciprocalArea.FromInverseSquareMeters(-value), -quantity);
}
public void ToString_NullArgs_ThrowsArgumentNullException()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Throws <ArgumentNullException>(() => quantity.ToString(null, "g", null));
}