public void more_than_one_standard_prefix_is_not_allowed(string invalid)
{
var ctx = new StandardMeasureContext("Empty");
ctx.TryParse(invalid, out var u).Should().BeFalse();
u.Should().BeNull();
}
public void new_units_clash_name_detection()
{
var c = new StandardMeasureContext("Empty");
var sievert = c.DefineAlias("Sv", "Sievert", FullFactor.Neutral, (c.Metre ^ 2) * (c.Second ^ 2), AutoStandardPrefix.Metric);
MeasureStandardPrefix.MetricPrefixes.Select(p => p.Abbreviation + "Sv")
.Where(a => c.CheckValidNewAbbreviation(a, AutoStandardPrefix.None) != MeasureContext.NewAbbreviationConflict.MatchPotentialAutoStandardPrefixedUnit)
.Should().BeEmpty();
MeasureStandardPrefix.BinaryPrefixes.Select(p => p.Abbreviation + "Sv")
.Where(a => c.CheckValidNewAbbreviation(a, AutoStandardPrefix.None) == MeasureContext.NewAbbreviationConflict.MatchPotentialAutoStandardPrefixedUnit)
.Should().BeEmpty();
var x = c.DefineAlias("xSv", "Bad name but okay...", FullFactor.Neutral, c.Ampere);
x.ToString().Should().Be("xSv");
c.Invoking(sut => sut.DefineAlias("", "no way", FullFactor.Neutral, c.Metre))
.Should().Throw <ArgumentException>();
c.Invoking(sut => sut.DefineAlias("p2", "no digit allowed", FullFactor.Neutral, c.Metre))
.Should().Throw <ArgumentException>();
c.Invoking(sut => sut.DefineAlias("p2p", "no digit allowed", FullFactor.Neutral, c.Metre))
.Should().Throw <ArgumentException>();
c.Invoking(sut => sut.DefineAlias("damol", "no way", FullFactor.Neutral, c.Metre))
.Should().Throw <ArgumentException>();
}
public void unknown_units(string invalid)
{
var ctx = new StandardMeasureContext("Empty");
ctx.TryParse(invalid, out var u).Should().BeFalse();
u.Should().BeNull();
}
public void parsing_combined_units(string text, string rewrite)
{
var ctx = new StandardMeasureContext("Empty");
ctx.TryParse(text, out var u).Should().BeTrue();
u.ToString().Should().Be(rewrite);
}
public void parsing_units_finds_the_best_prefix(string text, string rewrite)
{
var ctx = new StandardMeasureContext("Empty");
ctx.TryParse(text, out var u).Should().BeTrue();
u.ToString().Should().Be(rewrite);
}
public void parsing_dimensionless_units(string text, string rewrite)
{
var ctx = new StandardMeasureContext("Empty");
var percent = ctx.DefineAlias("%", "Percent", new ExpFactor(0, -2), MeasureUnit.None);
var permille = ctx.DefineAlias("‰", "Permille", new ExpFactor(0, -3), MeasureUnit.None);
var pertenthousand = ctx.DefineAlias("‱", "Pertenthousand", new ExpFactor(0, -4), MeasureUnit.None);
ctx.TryParse(text, out var u).Should().BeTrue();
u.ToString().Should().Be(rewrite);
}
public void parsing_unit_an_unknown_prefixed_unit_registers_it()
{
var ctx = new StandardMeasureContext("Empty");
ctx.TryParse("damol-8", out var u).Should().BeTrue();
u.ToString().Should().Be("damol-8");
u.Should().BeAssignableTo <ExponentMeasureUnit>();
(u as ExponentMeasureUnit).Exponent.Should().Be(-8);
var p = (u as ExponentMeasureUnit).AtomicMeasureUnit as PrefixedMeasureUnit;
p.Prefix.Should().Be(MeasureStandardPrefix.Deca);
p.AtomicMeasureUnit.Should().BeSameAs(ctx.Mole);
}
public void parsing_aliases()
{
var c = new StandardMeasureContext("Empty");
var kg = c.Kilogram;
var m = c.Metre;
var s = c.Second;
var newton = c.DefineAlias("N", "Newton", FullFactor.Neutral, kg * m * (s ^ -2));
var dyne = c.DefineAlias("dyn", "Dyne", new ExpFactor(0, -5), newton);
c.TryParse("dyn-1.N", out var u).Should().BeTrue();
u.ToString().Should().Be("N.dyn-1");
u.Should().BeSameAs(newton / dyne);
}
public void bad_unit_redefinition_throws_explicit_argument_exceptions()
{
StandardMeasureContext.Default.Invoking(x => x.DefineAlias("&", "", 2.0, MeasureUnit.Metre))
.Should().Throw <ArgumentException>().WithMessage("*InvalidCharacters*");
StandardMeasureContext.Default.Invoking(x => x.DefineAlias("kK", "ClashWithKiloKelvin", 2.0, MeasureUnit.Metre))
.Should().Throw <ArgumentException>().WithMessage("*MatchPotentialAutoStandardPrefixedUnit*");
StandardMeasureContext.Default.Invoking(x => x.DefineAlias("d", "TheCentiClashWithCandela", 2.0, MeasureUnit.Metre, AutoStandardPrefix.Metric))
.Should().Throw <ArgumentException>().WithMessage("*AmbiguousAutoStandardPrefix*");
StandardMeasureContext.Default.Invoking(x => x.DefineAlias("kg", "nimp", 2.0, MeasureUnit.Metre))
.Should().Throw <ArgumentException>().WithMessage("*new name 'nimp' differ from 'Kilogram'.");
var c = new StandardMeasureContext("Test");
var candela = c.Candela;
c.Invoking(x => x.DefineFundamental(candela.Abbreviation, candela.Name, AutoStandardPrefix.Metric)).Should().NotThrow();
c.Invoking(x => x.DefineFundamental(candela.Abbreviation, candela.Name, AutoStandardPrefix.Binary))
.Should().Throw <ArgumentException>().WithMessage("*new AutoStandardPrefix 'Binary' differ from 'Metric'.");
var kilometre = MeasureStandardPrefix.Kilo[c.Metre];
c.Invoking(x => x.DefineAlias(kilometre.Abbreviation, kilometre.Name, new ExpFactor(0, 3), c.Metre))
.Should().Throw <ArgumentException>().WithMessage("*new type 'AliasMeasureUnit' differ from 'PrefixedMeasureUnit'.");
c.DefineAlias("ktg", "Thing", 2.0, c.Unit);
c.Invoking(x => x.DefineAlias("ktg", "Thing", 2.0, c.Unit)).Should().NotThrow();
c.Invoking(x => x.DefineAlias("ktg", "NotThing", 2.0, c.Unit))
.Should().Throw <ArgumentException>().WithMessage("*new name 'NotThing' differ from 'Thing'.");
// Use ? at the comma position to handle comma or dot decimal separator.
c.Invoking(x => x.DefineAlias("ktg", "Thing", 2.5, c.Unit))
.Should().Throw <ArgumentException>().WithMessage("*new normalization factor '2?5' should be '2'.");
var xtg = c.DefineAlias("XTG", "2.5xThing", 2.5, c.Unit);
c.DefineAlias("XXTG", "2xXTG=5*Thing", 2.0, xtg);
c.Invoking(x => x.DefineAlias("XXTG", "2xXTG=5*Thing", 3.0, c.Metre))
.Should().Throw <ArgumentException>().WithMessage("*new definition unit 'm' is not compatible with 'XTG'.");
c.Invoking(x => x.DefineAlias("XXTG", "2xXTG=5*Thing", 2.0, c.Unit))
.Should().Throw <ArgumentException>().WithMessage("*new normalization factor '2' should be '5'.");
c.Invoking(x => x.DefineAlias("XXTG", "2xXTG=5*Thing", 3.0, xtg))
.Should().Throw <ArgumentException>().WithMessage("*new normalization factor '3' should be '2'.");
}
public void minute_and_inch_can_coexist_unless_inch_supports_metric_prefixes()
{
var cM = new StandardMeasureContext("WithMinute");
var minute = cM.DefineAlias("min", "Minute", new FullFactor(60), cM.Second);
cM.CheckValidNewAbbreviation("in", AutoStandardPrefix.None).Should().Be(MeasureContext.NewAbbreviationConflict.None);
cM.CheckValidNewAbbreviation("in", AutoStandardPrefix.Binary).Should().Be(MeasureContext.NewAbbreviationConflict.None);
cM.CheckValidNewAbbreviation("in", AutoStandardPrefix.Metric).Should().Be(MeasureContext.NewAbbreviationConflict.AmbiguousAutoStandardPrefix);
var cI = new StandardMeasureContext("WithInchMetric");
var inch = cI.DefineAlias("in",
"Inch",
2.54,
MeasureStandardPrefix.Centi[cI.Metre],
AutoStandardPrefix.Metric);
cI.CheckValidNewAbbreviation("min", AutoStandardPrefix.None).Should().Be(MeasureContext.NewAbbreviationConflict.MatchPotentialAutoStandardPrefixedUnit);
}
public void minute_and_inch_can_coexist_unless_inch_supports_metric_prefixes()
{
var cM = new StandardMeasureContext("WithMinute");
var minute = cM.DefineAlias("min", "Minute", new FullFactor(60), cM.Second);
cM.IsValidNewAbbreviation("in", AutoStandardPrefix.None).Should().BeTrue();
cM.IsValidNewAbbreviation("in", AutoStandardPrefix.Binary).Should().BeTrue();
cM.IsValidNewAbbreviation("in", AutoStandardPrefix.Metric).Should().BeFalse();
var cI = new StandardMeasureContext("WithInchMetric");
var inch = cI.DefineAlias("in",
"Inch",
2.54,
MeasureStandardPrefix.Centi[cI.Metre],
AutoStandardPrefix.Metric);
cI.IsValidNewAbbreviation("min", AutoStandardPrefix.None).Should().BeFalse();
}
public void measures_from_different_contexts_must_not_interfere()
{
var kilogram = MeasureUnit.Kilogram;
kilogram.Should().BeSameAs(StandardMeasureContext.Default.Kilogram);
var another = new StandardMeasureContext("Another");
var anotherKilogram = another.Kilogram;
anotherKilogram.Should().NotBeSameAs(kilogram);
another.Invoking(c => c.DefineAlias("derived", "Derived", 2, kilogram))
.Should().Throw <Exception>().Where(ex => ex.Message.Contains("Context mismatch"));
StandardMeasureContext.Default.Invoking(c => c.DefineAlias("derived", "Derived", 2, anotherKilogram))
.Should().Throw <Exception>().Where(ex => ex.Message.Contains("Context mismatch"));
Action a = () => Console.WriteLine(kilogram / anotherKilogram);
a.Should().Throw <Exception>().Where(ex => ex.Message.Contains("Context mismatch"));
}
public void Quantity_comparison()
{
var r0 = new Quantity();
var rM1 = -1.WithUnit(MeasureUnit.None);
var r2 = 2.WithUnit(MeasureUnit.None);
var qG1 = 1.WithUnit(MeasureUnit.Gram);
var qG2 = 2.WithUnit(MeasureUnit.Gram);
var qM1 = 1.WithUnit(MeasureUnit.Metre);
var qM2 = 2.WithUnit(MeasureUnit.Metre);
var cA = new StandardMeasureContext("A");
var cB = new StandardMeasureContext("B");
var q2CA = 3.WithUnit(cA.Gram);
var q1CB = -1.WithUnit(cB.Gram);
var l = new[] { q2CA, q1CB, qM2, qM1, qG1, r0, qG2, r2, rM1 };
Array.Sort(l);
String.Join(", ", l.Select(e => $"{e} ({(e.Unit.Context == null ? "*" : e.Unit.Context.Name)})"))
.Should().Be("-1 (*), 0 (*), 2 (*), 1 g (), 2 g (), 1 m (), 2 m (), 3 g (A), -1 g (B)");
}
public void simple_operations()
{
var c = new StandardMeasureContext("Empty");
var metre = c.Metre;
var second = c.Second;
var kilometre = MeasureStandardPrefix.Kilo[metre];
var minute = c.DefineAlias("min", "Minute", 60, second);
var hour = c.DefineAlias("h", "Hour", 60, minute);
var speed = kilometre / hour;
var myDistance = 3.WithUnit(kilometre);
var mySpeed = 6.WithUnit(speed);
var myTime = myDistance / mySpeed;
myTime.ToString(CultureInfo.InvariantCulture).Should().Be("0.5 h");
myTime.CanConvertTo(minute).Should().BeTrue();
myTime.ConvertTo(minute).ToString().Should().Be("30 min");
myTime.CanConvertTo(second).Should().BeTrue();
myTime.ConvertTo(second).ToString().Should().Be("1800 s");
}
