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 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_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 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");
}
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();
}
