public static void CreateMilligrams()
{
using var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Grams, settings.Milli);
settings.Grams.PrefixConversions.Add(conversion);
Assert.AreEqual("Milligrams", conversion.Name);
Assert.AreEqual("mg", conversion.Symbol);
Assert.AreEqual(1E-6, conversion.Factor);
}
public static void CreateMilliAmperes()
{
using var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Amperes, settings.Milli);
settings.Amperes.PrefixConversions.Add(conversion);
Assert.AreEqual("Milliamperes", conversion.Name);
Assert.AreEqual("mA", conversion.Symbol);
Assert.AreEqual(0.001, conversion.Factor);
}
public void PrefixMicroConversion()
{
var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Metres, settings.Micro);
settings.Metres.PrefixConversions.Add(conversion);
Assert.AreEqual("micrometres/1000000", conversion.ToSi);
Assert.AreEqual("1000000*metres", conversion.FromSi);
Assert.AreEqual("1 µm = 1E-06 m", conversion.SymbolConversion);
Assert.AreEqual(true, conversion.CanRoundtrip);
}
public void NestedFactorConversion()
{
var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Grams, settings.Milli);
settings.Grams.PrefixConversions.Add(conversion);
Assert.AreEqual("milligrams/1000000", conversion.ToSi);
Assert.AreEqual("1000000*kilograms", conversion.FromSi);
Assert.AreEqual("1 mg = 1E-06 kg", conversion.SymbolConversion);
Assert.AreEqual(true, conversion.CanRoundtrip);
}
public async Task NestedFactorConversion()
{
var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Grams, settings.Milli);
settings.Grams.PrefixConversions.Add(conversion);
Assert.AreEqual("milligrams / 1000000", conversion.ToSi);
Assert.AreEqual("1000000 * kilograms", conversion.FromSi);
Assert.AreEqual("1 mg = 1E-06 kg", await conversion.GetSymbolConversionAsync().ConfigureAwait(false));
Assert.AreEqual(true, await conversion.CanRoundtripAsync().ConfigureAwait(false));
}
public async Task PrefixMicroConversion()
{
var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Metres, settings.Micro);
settings.Metres.PrefixConversions.Add(conversion);
Assert.AreEqual("micrometres / 1000000", conversion.ToSi);
Assert.AreEqual("1000000 * metres", conversion.FromSi);
Assert.AreEqual("1 µm = 1E-06 m", await conversion.GetSymbolConversionAsync().ConfigureAwait(false));
Assert.AreEqual(true, await conversion.CanRoundtripAsync().ConfigureAwait(false));
}
public void SquareMillimetres()
{
var settings = MockSettings.Create();
var millimetres = PrefixConversion.Create(settings.Metres, settings.Milli);
settings.Metres.PrefixConversions.Add(millimetres);
var millimetrePart = PartConversion.CreatePart(2, millimetres);
var conversion = PartConversion.Create(settings.Metres, millimetrePart);
Assert.AreEqual("mm²", conversion.Symbol);
Assert.AreEqual("SquareMillimetres", conversion.Name);
Assert.AreEqual(1E-6, conversion.Factor);
}
public void SetIsUsedToTrueAddsConversion()
{
var settings = MockSettings.Create();
var prefixConversion = PrefixConversion.Create(settings.Amperes, settings.Milli);
var conversionVm = PrefixConversionVm.Create(settings.Amperes, settings.Milli);
Assert.IsFalse(conversionVm.IsUsed);
Assert.IsEmpty(settings.Amperes.PrefixConversions);
conversionVm.IsUsed = true;
var expected = new[] { prefixConversion };
CollectionAssert.AreEqual(expected, settings.Amperes.PrefixConversions, PrefixConversionComparer.Default);
}
public void PartConversionPrefix()
{
var settings = MockSettings.Create();
var millimetreConversion = PrefixConversion.Create(settings.Metres, settings.Milli);
settings.Metres.PrefixConversions.Add(millimetreConversion);
var milliMetresPart = PartConversion.CreatePart(1, millimetreConversion);
var secondsPart = PartConversion.CreatePart(-1, settings.Seconds);
var conversion = PartConversion.Create(settings.MetresPerSecond, milliMetresPart, secondsPart);
settings.MetresPerSecond.PartConversions.Add(conversion);
Assert.AreEqual("millimetresPerSecond/1000", conversion.ToSi);
Assert.AreEqual("1000*metresPerSecond", conversion.FromSi);
Assert.AreEqual("1 mm/s = 0.001 m/s", conversion.SymbolConversion);
Assert.AreEqual(true, conversion.CanRoundtrip);
}
public void MilliGramsPerCubicMetre()
{
var settings = MockSettings.Create();
var milligram = PrefixConversion.Create(settings.Grams, settings.Milli);
settings.Grams.PrefixConversions.Add(milligram);
var milliGramPart = PartConversion.CreatePart(1, milligram);
var volumePart = PartConversion.CreatePart(-1, settings.CubicMetres);
var conversion = PartConversion.Create(settings.Kilograms, milliGramPart, volumePart);
Assert.AreEqual("mg/m³", conversion.Symbol);
Assert.AreEqual("MilligramsPerCubicMetre", conversion.Name);
Assert.AreEqual(1E-6, conversion.Factor);
}
public void CubicMillimetres()
{
var settings = MockSettings.Create();
var millimetres = PrefixConversion.Create(settings.Metres, settings.Milli);
settings.Metres.PrefixConversions.Add(millimetres);
var conversion = PartConversion.Create(settings.CubicMetres, new PartConversion.PowerPart(3, millimetres));
var conversionVm = new PartConversionVm(settings.CubicMetres, conversion);
Assert.AreEqual(1E-9, conversionVm.Conversion.Factor);
Assert.AreEqual("cubicMillimetres/1000000000", conversionVm.Conversion.ToSi);
Assert.AreEqual("1000000000*cubicMetres", conversionVm.Conversion.FromSi);
Assert.AreEqual("1 mm³ = 1E-09 m³", conversionVm.Conversion.SymbolConversion);
Assert.AreEqual(true, conversionVm.Conversion.CanRoundtrip);
}
public void IsUsed()
{
var settings = MockSettings.Create();
var millimetres = PrefixConversion.Create(settings.Metres, settings.Milli);
settings.Metres.PrefixConversions.Add(millimetres);
var conversion = PartConversion.Create(settings.CubicMetres, new PartConversion.PowerPart(3, millimetres));
var conversionVm = new PartConversionVm(settings.CubicMetres, conversion);
conversionVm.IsUsed = true;
CollectionAssert.Contains(settings.CubicMetres.PartConversions, conversion);
conversionVm.IsUsed = false;
CollectionAssert.DoesNotContain(settings.CubicMetres.PartConversions, conversion);
}
public static async Task CubicMillimetresAsync()
{
using var settings = MockSettings.Create();
var millimetres = PrefixConversion.Create(settings.Metres, settings.Milli);
settings.Metres.PrefixConversions.Add(millimetres);
var conversion = PartConversion.Create(settings.CubicMetres, new PowerPart(3, millimetres));
using var conversionVm = new PartConversionVm(settings.CubicMetres, conversion);
Assert.AreEqual(1E-9, ((PartConversion)conversionVm.Conversion).Factor);
Assert.AreEqual("cubicMillimetres / 1000000000", conversionVm.Conversion.ToSi);
Assert.AreEqual("1000000000 * cubicMetres", conversionVm.Conversion.FromSi);
Assert.AreEqual("1 mm³ = 1E-09 m³", await conversionVm.Conversion.GetSymbolConversionAsync().ConfigureAwait(false));
Assert.AreEqual(true, await conversionVm.Conversion.CanRoundtripAsync().ConfigureAwait(false));
}
public async Task MilliMetresPerSecondCubed()
{
var settings = MockSettings.Create();
var millimetres = PrefixConversion.Create(settings.Metres, settings.Milli);
settings.Metres.PrefixConversions.Add(millimetres);
var metrePart = PartConversion.CreatePart(1, millimetres);
var secondPart = PartConversion.CreatePart(-2, settings.Seconds);
var conversion = PartConversion.Create(settings.MetresPerSecondSquared, metrePart, secondPart);
Assert.AreEqual("mm/s²", conversion.Symbol);
Assert.AreEqual("MillimetresPerSecondSquared", conversion.Name);
Assert.AreEqual(0.001, conversion.Factor);
Assert.AreEqual(true, await conversion.CanRoundtripAsync().ConfigureAwait(false));
}
public async Task PartConversionPrefix()
{
var settings = MockSettings.Create();
var millimetreConversion = PrefixConversion.Create(settings.Metres, settings.Milli);
settings.Metres.PrefixConversions.Add(millimetreConversion);
var milliMetresPart = PartConversion.CreatePart(1, millimetreConversion);
var secondsPart = PartConversion.CreatePart(-1, settings.Seconds);
var conversion = PartConversion.Create(settings.MetresPerSecond, milliMetresPart, secondsPart);
settings.MetresPerSecond.PartConversions.Add(conversion);
Assert.AreEqual("millimetresPerSecond / 1000", conversion.ToSi);
Assert.AreEqual("1000 * metresPerSecond", conversion.FromSi);
Assert.AreEqual("1 mm/s = 0.001 m/s", await conversion.GetSymbolConversionAsync().ConfigureAwait(false));
Assert.AreEqual(true, await conversion.CanRoundtripAsync().ConfigureAwait(false));
}
public void CentimetresPerMinute()
{
var settings = MockSettings.Create();
var centi = new Prefix("Centi", "c", -2);
settings.Prefixes.Add(centi);
var centimetresConversion = PrefixConversion.Create(settings.Metres, centi);
var minuteConversion = new FactorConversion("Minute", "min", 60);
settings.Seconds.FactorConversions.Add(minuteConversion);
settings.Metres.PrefixConversions.Add(centimetresConversion);
var centiMetresPart = PartConversion.CreatePart(1, centimetresConversion);
var minutesPart = PartConversion.CreatePart(-1, minuteConversion);
var conversion = PartConversion.Create(settings.MetresPerSecond, centiMetresPart, minutesPart);
settings.MetresPerSecond.PartConversions.Add(conversion);
Assert.AreEqual("centimetresPerMinute/6000", conversion.ToSi);
Assert.AreEqual("6000*metresPerSecond", conversion.FromSi);
Assert.AreEqual("1 cm/min = 0.000166666666666667 m/s", conversion.SymbolConversion);
Assert.AreEqual(true, conversion.CanRoundtrip);
}
