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 InverseReturnsArea(double value, double expected)
{
var inverseArea = new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMeter);
var area = inverseArea.Inverse();
Assert.Equal(expected, area.SquareMeters);
}
public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
{
var quantity = new ReciprocalArea();
Assert.Equal(0, quantity.Value);
Assert.Equal(ReciprocalAreaUnit.InverseSquareMeter, quantity.Unit);
}
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 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 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 From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
{
var quantity00 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareCentimeter);
AssertEx.EqualTolerance(1, quantity00.InverseSquareCentimeters, InverseSquareCentimetersTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareCentimeter, quantity00.Unit);
var quantity01 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareDecimeter);
AssertEx.EqualTolerance(1, quantity01.InverseSquareDecimeters, InverseSquareDecimetersTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareDecimeter, quantity01.Unit);
var quantity02 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareFoot);
AssertEx.EqualTolerance(1, quantity02.InverseSquareFeet, InverseSquareFeetTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareFoot, quantity02.Unit);
var quantity03 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareInch);
AssertEx.EqualTolerance(1, quantity03.InverseSquareInches, InverseSquareInchesTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareInch, quantity03.Unit);
var quantity04 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareKilometer);
AssertEx.EqualTolerance(1, quantity04.InverseSquareKilometers, InverseSquareKilometersTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareKilometer, quantity04.Unit);
var quantity05 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareMeter);
AssertEx.EqualTolerance(1, quantity05.InverseSquareMeters, InverseSquareMetersTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareMeter, quantity05.Unit);
var quantity06 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareMicrometer);
AssertEx.EqualTolerance(1, quantity06.InverseSquareMicrometers, InverseSquareMicrometersTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareMicrometer, quantity06.Unit);
var quantity07 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareMile);
AssertEx.EqualTolerance(1, quantity07.InverseSquareMiles, InverseSquareMilesTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareMile, quantity07.Unit);
var quantity08 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareMillimeter);
AssertEx.EqualTolerance(1, quantity08.InverseSquareMillimeters, InverseSquareMillimetersTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareMillimeter, quantity08.Unit);
var quantity09 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareYard);
AssertEx.EqualTolerance(1, quantity09.InverseSquareYards, InverseSquareYardsTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseSquareYard, quantity09.Unit);
var quantity10 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseUsSurveySquareFoot);
AssertEx.EqualTolerance(1, quantity10.InverseUsSurveySquareFeet, InverseUsSurveySquareFeetTolerance);
Assert.Equal(ReciprocalAreaUnit.InverseUsSurveySquareFoot, quantity10.Unit);
}
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 As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
{
var quantity = new ReciprocalArea(value: 1, unit: ReciprocalArea.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 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 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 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 ReciprocalArea_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
{
var quantity = new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareMeter);
QuantityInfo <ReciprocalAreaUnit> quantityInfo = quantity.QuantityInfo;
Assert.Equal(ReciprocalArea.Zero, quantityInfo.Zero);
Assert.Equal("ReciprocalArea", quantityInfo.Name);
Assert.Equal(QuantityType.ReciprocalArea, quantityInfo.QuantityType);
var units = EnumUtils.GetEnumValues <ReciprocalAreaUnit>().Except(new[] { ReciprocalAreaUnit.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 = 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_ChangeType_InvalidType_ThrowsInvalidCastException()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Throws <InvalidCastException>(() => Convert.ChangeType(quantity, typeof(QuantityFormatter)));
}
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_QuantityInfo_EqualsQuantityInfo()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal(ReciprocalArea.Info, Convert.ChangeType(quantity, typeof(QuantityInfo)));
}
public void Convert_ChangeType_UnitType_EqualsUnit()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(ReciprocalAreaUnit)));
}
public void Convert_ChangeType_SelfType_EqualsSelf()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(ReciprocalArea)));
}
public void Convert_ToUInt64_EqualsValueAsSameType()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity));
}
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 GetHashCode_Equals()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal(new { ReciprocalArea.Info.Name, quantity.Value, quantity.Unit }.GetHashCode(), quantity.GetHashCode());
}
public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value)
{
var quantity = ReciprocalArea.FromInverseSquareMeters(value);
Assert.Equal(ReciprocalArea.FromInverseSquareMeters(-value), -quantity);
}
public void ToString_NullProvider_EqualsCurrentUICulture()
{
var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
Assert.Equal(quantity.ToString(CultureInfo.CurrentUICulture, "g"), quantity.ToString(null, "g"));
}
