public void ArithmeticOperators()
{
VolumeConcentration v = VolumeConcentration.FromDecimalFractions(1);
AssertEx.EqualTolerance(-1, -v.DecimalFractions, DecimalFractionsTolerance);
AssertEx.EqualTolerance(2, (VolumeConcentration.FromDecimalFractions(3) - v).DecimalFractions, DecimalFractionsTolerance);
AssertEx.EqualTolerance(2, (v + v).DecimalFractions, DecimalFractionsTolerance);
AssertEx.EqualTolerance(10, (v * 10).DecimalFractions, DecimalFractionsTolerance);
AssertEx.EqualTolerance(10, (10 * v).DecimalFractions, DecimalFractionsTolerance);
AssertEx.EqualTolerance(2, (VolumeConcentration.FromDecimalFractions(10) / 5).DecimalFractions, DecimalFractionsTolerance);
AssertEx.EqualTolerance(2, VolumeConcentration.FromDecimalFractions(10) / VolumeConcentration.FromDecimalFractions(5), DecimalFractionsTolerance);
}
public void ComparisonOperators()
{
VolumeConcentration oneDecimalFraction = VolumeConcentration.FromDecimalFractions(1);
VolumeConcentration twoDecimalFractions = VolumeConcentration.FromDecimalFractions(2);
Assert.True(oneDecimalFraction < twoDecimalFractions);
Assert.True(oneDecimalFraction <= twoDecimalFractions);
Assert.True(twoDecimalFractions > oneDecimalFraction);
Assert.True(twoDecimalFractions >= oneDecimalFraction);
Assert.False(oneDecimalFraction > twoDecimalFractions);
Assert.False(oneDecimalFraction >= twoDecimalFractions);
Assert.False(twoDecimalFractions < oneDecimalFraction);
Assert.False(twoDecimalFractions <= oneDecimalFraction);
}
public void EqualityOperators()
{
var a = VolumeConcentration.FromDecimalFractions(1);
var b = VolumeConcentration.FromDecimalFractions(2);
// 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
}
public void EqualsReturnsFalseOnNull()
{
VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(1);
Assert.False(decimalfraction.Equals(null));
}
public void EqualsReturnsFalseOnTypeMismatch()
{
VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(1);
Assert.False(decimalfraction.Equals(new object()));
}
public void CompareToThrowsOnNull()
{
VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(1);
Assert.Throws <ArgumentNullException>(() => decimalfraction.CompareTo(null));
}
public void CompareToThrowsOnTypeMismatch()
{
VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(1);
Assert.Throws <ArgumentException>(() => decimalfraction.CompareTo(new object()));
}
public void ToUnit()
{
var decimalfraction = VolumeConcentration.FromDecimalFractions(1);
var centilitersperliterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.CentilitersPerLiter);
AssertEx.EqualTolerance(CentilitersPerLiterInOneDecimalFraction, (double)centilitersperliterQuantity.Value, CentilitersPerLiterTolerance);
Assert.Equal(VolumeConcentrationUnit.CentilitersPerLiter, centilitersperliterQuantity.Unit);
var centiliterspermililiterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.CentilitersPerMililiter);
AssertEx.EqualTolerance(CentilitersPerMililiterInOneDecimalFraction, (double)centiliterspermililiterQuantity.Value, CentilitersPerMililiterTolerance);
Assert.Equal(VolumeConcentrationUnit.CentilitersPerMililiter, centiliterspermililiterQuantity.Unit);
var decilitersperliterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.DecilitersPerLiter);
AssertEx.EqualTolerance(DecilitersPerLiterInOneDecimalFraction, (double)decilitersperliterQuantity.Value, DecilitersPerLiterTolerance);
Assert.Equal(VolumeConcentrationUnit.DecilitersPerLiter, decilitersperliterQuantity.Unit);
var deciliterspermililiterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.DecilitersPerMililiter);
AssertEx.EqualTolerance(DecilitersPerMililiterInOneDecimalFraction, (double)deciliterspermililiterQuantity.Value, DecilitersPerMililiterTolerance);
Assert.Equal(VolumeConcentrationUnit.DecilitersPerMililiter, deciliterspermililiterQuantity.Unit);
var decimalfractionQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.DecimalFraction);
AssertEx.EqualTolerance(DecimalFractionsInOneDecimalFraction, (double)decimalfractionQuantity.Value, DecimalFractionsTolerance);
Assert.Equal(VolumeConcentrationUnit.DecimalFraction, decimalfractionQuantity.Unit);
var litersperliterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.LitersPerLiter);
AssertEx.EqualTolerance(LitersPerLiterInOneDecimalFraction, (double)litersperliterQuantity.Value, LitersPerLiterTolerance);
Assert.Equal(VolumeConcentrationUnit.LitersPerLiter, litersperliterQuantity.Unit);
var literspermililiterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.LitersPerMililiter);
AssertEx.EqualTolerance(LitersPerMililiterInOneDecimalFraction, (double)literspermililiterQuantity.Value, LitersPerMililiterTolerance);
Assert.Equal(VolumeConcentrationUnit.LitersPerMililiter, literspermililiterQuantity.Unit);
var microlitersperliterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.MicrolitersPerLiter);
AssertEx.EqualTolerance(MicrolitersPerLiterInOneDecimalFraction, (double)microlitersperliterQuantity.Value, MicrolitersPerLiterTolerance);
Assert.Equal(VolumeConcentrationUnit.MicrolitersPerLiter, microlitersperliterQuantity.Unit);
var microliterspermililiterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.MicrolitersPerMililiter);
AssertEx.EqualTolerance(MicrolitersPerMililiterInOneDecimalFraction, (double)microliterspermililiterQuantity.Value, MicrolitersPerMililiterTolerance);
Assert.Equal(VolumeConcentrationUnit.MicrolitersPerMililiter, microliterspermililiterQuantity.Unit);
var millilitersperliterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.MillilitersPerLiter);
AssertEx.EqualTolerance(MillilitersPerLiterInOneDecimalFraction, (double)millilitersperliterQuantity.Value, MillilitersPerLiterTolerance);
Assert.Equal(VolumeConcentrationUnit.MillilitersPerLiter, millilitersperliterQuantity.Unit);
var milliliterspermililiterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.MillilitersPerMililiter);
AssertEx.EqualTolerance(MillilitersPerMililiterInOneDecimalFraction, (double)milliliterspermililiterQuantity.Value, MillilitersPerMililiterTolerance);
Assert.Equal(VolumeConcentrationUnit.MillilitersPerMililiter, milliliterspermililiterQuantity.Unit);
var nanolitersperliterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.NanolitersPerLiter);
AssertEx.EqualTolerance(NanolitersPerLiterInOneDecimalFraction, (double)nanolitersperliterQuantity.Value, NanolitersPerLiterTolerance);
Assert.Equal(VolumeConcentrationUnit.NanolitersPerLiter, nanolitersperliterQuantity.Unit);
var nanoliterspermililiterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.NanolitersPerMililiter);
AssertEx.EqualTolerance(NanolitersPerMililiterInOneDecimalFraction, (double)nanoliterspermililiterQuantity.Value, NanolitersPerMililiterTolerance);
Assert.Equal(VolumeConcentrationUnit.NanolitersPerMililiter, nanoliterspermililiterQuantity.Unit);
var partperbillionQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.PartPerBillion);
AssertEx.EqualTolerance(PartsPerBillionInOneDecimalFraction, (double)partperbillionQuantity.Value, PartsPerBillionTolerance);
Assert.Equal(VolumeConcentrationUnit.PartPerBillion, partperbillionQuantity.Unit);
var partpermillionQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.PartPerMillion);
AssertEx.EqualTolerance(PartsPerMillionInOneDecimalFraction, (double)partpermillionQuantity.Value, PartsPerMillionTolerance);
Assert.Equal(VolumeConcentrationUnit.PartPerMillion, partpermillionQuantity.Unit);
var partperthousandQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.PartPerThousand);
AssertEx.EqualTolerance(PartsPerThousandInOneDecimalFraction, (double)partperthousandQuantity.Value, PartsPerThousandTolerance);
Assert.Equal(VolumeConcentrationUnit.PartPerThousand, partperthousandQuantity.Unit);
var partpertrillionQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.PartPerTrillion);
AssertEx.EqualTolerance(PartsPerTrillionInOneDecimalFraction, (double)partpertrillionQuantity.Value, PartsPerTrillionTolerance);
Assert.Equal(VolumeConcentrationUnit.PartPerTrillion, partpertrillionQuantity.Unit);
var percentQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.Percent);
AssertEx.EqualTolerance(PercentInOneDecimalFraction, (double)percentQuantity.Value, PercentTolerance);
Assert.Equal(VolumeConcentrationUnit.Percent, percentQuantity.Unit);
var picolitersperliterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.PicolitersPerLiter);
AssertEx.EqualTolerance(PicolitersPerLiterInOneDecimalFraction, (double)picolitersperliterQuantity.Value, PicolitersPerLiterTolerance);
Assert.Equal(VolumeConcentrationUnit.PicolitersPerLiter, picolitersperliterQuantity.Unit);
var picoliterspermililiterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.PicolitersPerMililiter);
AssertEx.EqualTolerance(PicolitersPerMililiterInOneDecimalFraction, (double)picoliterspermililiterQuantity.Value, PicolitersPerMililiterTolerance);
Assert.Equal(VolumeConcentrationUnit.PicolitersPerMililiter, picoliterspermililiterQuantity.Unit);
}
public void FromDecimalFractions_WithNanValue_ThrowsArgumentException()
{
Assert.Throws <ArgumentException>(() => VolumeConcentration.FromDecimalFractions(double.NaN));
}
public void FromDecimalFractions_WithInfinityValue_ThrowsArgumentException()
{
Assert.Throws <ArgumentException>(() => VolumeConcentration.FromDecimalFractions(double.PositiveInfinity));
Assert.Throws <ArgumentException>(() => VolumeConcentration.FromDecimalFractions(double.NegativeInfinity));
}
public void NumberToDecimalFractionsTest() => Assert.Equal(VolumeConcentration.FromDecimalFractions(2), 2.DecimalFractions());
public static VolumeConcentration DecimalFractions <T>(this T value) => VolumeConcentration.FromDecimalFractions(Convert.ToDecimal(value));
/// <summary>Get <see cref="VolumeConcentration" /> from <see cref="MassConcentration" /> divided by the component's <see cref="Density" />.</summary>
public static VolumeConcentration operator /(MassConcentration massConcentration, Density componentDensity)
{
return(VolumeConcentration.FromDecimalFractions(massConcentration.KilogramsPerCubicMeter / componentDensity.KilogramsPerCubicMeter));
}
