public void ParseError(IErrorCase @case)
{
var pos = @case.Start;
Assert.Throws <FormatException>(() => SymbolAndPowerReader.Read(@case.Text, ref pos));
Assert.AreEqual(@case.ExpectedEnd, pos);
}
public void ParseError(IErrorData data)
{
var pos = data.Start;
Assert.Throws <FormatException>(() => SymbolAndPowerReader.Read(data.Text, ref pos));
Assert.AreEqual(data.ExpectedEnd, pos);
}
public void TryParseError(IErrorCase @case)
{
var pos = @case.Start;
Assert.AreEqual(false, SymbolAndPowerReader.TryRead(@case.Text, ref pos, out SymbolAndPower sap));
Assert.AreEqual(default(SymbolAndPower), sap);
Assert.AreEqual(@case.ExpectedEnd, pos);
}
public void TryParseSuccess(ISuccessData data)
{
var pos = data.Start;
Assert.AreEqual(true, SymbolAndPowerReader.TryRead(data.Text, ref pos, out SymbolAndPower actual));
Assert.AreEqual(data.Expected, actual);
Assert.AreEqual(data.ExpectedEnd, pos);
}
public void ParseSuccess(ISuccessData data)
{
var pos = data.Start;
var actual = SymbolAndPowerReader.Read(data.Text, ref pos);
Assert.AreEqual(data.Expected, actual);
Assert.AreEqual(data.ExpectedEnd, pos);
}
internal IReadOnlyList <SymbolAndPower> AsSymbolAndPowers()
{
if (SymbolAndPowerReader.TryRead(this.Conversion.Symbol, out var symbolAndPowers))
{
return(symbolAndPowers.Select(x => new SymbolAndPower(x.Symbol, x.Power * this.Power)).ToList());
}
throw new InvalidOperationException();
}
internal static string NormalizeSymbol(this string symbol)
{
if (SymbolAndPowerReader.TryRead(symbol, out var symbolAndPowers))
{
return(symbolAndPowers.AsSymbol());
}
return($"Failed normalizing {symbol}");
}
public void TryTokenizeError(IErrorCase @case)
{
var pos = @case.Start;
var success = SymbolAndPowerReader.TryRead(@case.Text, ref pos, out IReadOnlyList <SymbolAndPower> actual);
Assert.AreEqual(false, success);
Assert.AreEqual(@case.Start, pos);
CollectionAssert.AreEqual(null, actual);
}
internal static string NormalizeSymbol(this string symbol)
{
if (SymbolAndPowerReader.TryRead(symbol, out IReadOnlyList<SymbolAndPower> symbolAndPowers))
{
return symbolAndPowers.AsSymbol();
}
return $"Failed normalizing {symbol}";
}
public void TryTokenizeError(IErrorData data)
{
var pos = data.Start;
IReadOnlyList <SymbolAndPower> actual;
var success = SymbolAndPowerReader.TryRead(data.Text, ref pos, out actual);
Assert.AreEqual(false, success);
Assert.AreEqual(data.Start, pos);
CollectionAssert.AreEqual(null, actual);
}
public void TryParseError(IErrorData data)
{
var pos = data.Start;
SymbolAndPower sap;
var success = SymbolAndPowerReader.TryRead(data.Text, ref pos, out sap);
Assert.AreEqual(false, success);
Assert.AreEqual(default(SymbolAndPower), sap);
Assert.AreEqual(data.ExpectedEnd, pos);
}
public void TryReadSuccess(ISuccessData data)
{
var pos = data.Start;
var success = SymbolAndPowerReader.TryRead(data.Text, ref pos, out IReadOnlyList <SymbolAndPower> actual);
////Console.WriteLine("expected: {0}", data.ToString(data.Tokens));
////Console.WriteLine("actual: {0}", data.ToString(actual));
Assert.AreEqual(true, success);
Assert.AreEqual(data.ExpectedEnd, pos);
CollectionAssert.AreEqual((IEnumerable)data.Expected, actual);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
var text = value as string;
if (string.IsNullOrWhiteSpace(text))
{
return(null);
}
var settings = Settings.Instance;
var pos = 0;
_ = WhiteSpaceReader.TryRead(text, ref pos);
var indexOf = text.IndexOf("1/", pos, StringComparison.Ordinal);
if (indexOf >= 0)
{
pos = indexOf + 2;
}
if (SymbolAndPowerReader.TryRead(text, ref pos, out IReadOnlyList <SymbolAndPower> result))
{
if (WhiteSpaceReader.IsRestWhiteSpace(text, pos))
{
var unitAndPowers = result.Select(sap => UnitAndPower.Create(settings.AllUnits.Single(x => x.Symbol == sap.Symbol), sap.Power))
.ToList();
var unitParts = new UnitParts(unitAndPowers);
if (indexOf < 0)
{
return(unitParts);
}
return(unitParts.Inverse());
}
}
return(text);
}
private bool IsValidPrefixUnit(INameAndSymbol item)
{
if (this.settings.Prefixes.Any(p => item.Name.StartsWith(p.Name, StringComparison.OrdinalIgnoreCase)))
{
return(false);
}
var baseUnit = item as BaseUnit;
if (baseUnit != null)
{
return(true);
}
var derivedUnit = item as DerivedUnit;
if (derivedUnit != null)
{
IReadOnlyList <SymbolAndPower> symbolAndPowers;
if (SymbolAndPowerReader.TryRead(derivedUnit.Symbol, out symbolAndPowers))
{
return(symbolAndPowers.Count == 1 && symbolAndPowers[0].Power == 1);
}
return(false);
}
var factorConversion = item as FactorConversion;
if (factorConversion != null)
{
return(true);
}
return(false);
}
