public void ParseInt64_Negative()
{
var value = new ValueCursor("-56x");
Assert.True(value.MoveNext());
long result;
Assert.IsNull(value.ParseInt64 <string>(out result));
Assert.AreEqual(-56L, result);
}
public void ParseInt64Digits_TooFewDigits()
{
var value = new ValueCursor("a12b");
Assert.True(value.MoveNext());
ValidateCurrentCharacter(value, 0, 'a');
Assert.True(value.MoveNext());
Assert.False(value.ParseInt64Digits(3, 3, out long actual));
ValidateCurrentCharacter(value, 1, '1');
}
public void Parse_Partial_Invalid()
{
var value = new ValueCursor("x20:y");
value.MoveNext();
value.MoveNext();
var result = SimpleOffsetPattern.ParsePartial(value);
Assert.Throws <UnparsableValueException>(() => result.GetValueOrThrow());
}
public void ParseInt64Digits_Maximum()
{
var value = new ValueCursor("12");
Assert.True(value.MoveNext());
long actual;
Assert.True(value.ParseInt64Digits(1, 2, out actual));
Assert.AreEqual(12, actual);
}
public void ParseInt64_Simple()
{
var value = new ValueCursor("56x");
Assert.True(value.MoveNext());
Assert.IsNull(value.ParseInt64 <string>(out long result));
Assert.AreEqual(56L, result);
// Cursor ends up post-number
Assert.AreEqual(2, value.Index);
}
public void ParseInt64Digits_NoNumber()
{
var value = new ValueCursor("abc");
Assert.True(value.MoveNext());
long actual;
Assert.False(value.ParseInt64Digits(1, 2, out actual));
ValidateCurrentCharacter(value, 0, 'a');
}
public void Match_Char()
{
var value = new ValueCursor("abc");
Assert.True(value.MoveNext(), "GetNext() 1");
Assert.True(value.Match('a'), "First character");
Assert.True(value.Match('b'), "Second character");
Assert.True(value.Match('c'), "Third character");
Assert.False(value.MoveNext(), "GetNext() end");
}
public void ParseInt64_MaxValue()
{
var value = new ValueCursor("9223372036854775807");
Assert.True(value.MoveNext());
long result;
Assert.IsNull(value.ParseInt64 <string>(out result));
Assert.AreEqual(long.MaxValue, result);
}
public void ParseInt64_NumberOutOfRange_MinValueLeadingDigits()
{
var value = new ValueCursor("-9223372036854775809");
Assert.True(value.MoveNext());
long result;
Assert.IsNotNull(value.ParseInt64 <string>(out result));
// Cursor has not moved
Assert.AreEqual(0, value.Index);
}
public void ParseFraction_NonAscii_NeverMatches()
{
// Arabic-Indic digits 0 and 1. See
// http://www.unicode.org/charts/PDF/U0600.pdf
var value = new ValueCursor("\u0660\u0661");
Assert.True(value.MoveNext());
int actual;
Assert.False(value.ParseFraction(2, 2, out actual, true));
}
public void ParseInt64Digits_LargeNumber()
{
var value = new ValueCursor("9999999999999");
Assert.True(value.MoveNext());
long actual;
Assert.True(value.ParseInt64Digits(1, 13, out actual));
Assert.AreEqual(actual, 9999999999999L);
Assert.Greater(9999999999999L, int.MaxValue);
}
public void ParseInt64Digits_MinimumNonDigits()
{
var value = new ValueCursor("1abc");
Assert.True(value.MoveNext());
long actual;
Assert.True(value.ParseInt64Digits(1, 2, out actual));
Assert.AreEqual(1, actual);
ValidateCurrentCharacter(value, 1, 'a');
}
public void ParseInt64Digits_Minimum()
{
var value = new ValueCursor("1");
value.MoveNext();
long actual;
Assert.True(value.ParseInt64Digits(1, 2, out actual));
Assert.AreEqual(1, actual);
ValidateEndOfString(value);
}
public void ParseInt64Digits_MaximumMoreDigits()
{
var value = new ValueCursor("1234");
Assert.True(value.MoveNext());
long actual;
Assert.True(value.ParseInt64Digits(1, 2, out actual));
Assert.AreEqual(12, actual);
ValidateCurrentCharacter(value, 2, '3');
}
public void ParseInt64_NegativeThenNonDigit()
{
var value = new ValueCursor("-x");
Assert.True(value.MoveNext());
long result;
Assert.IsNotNull(value.ParseInt64 <string>(out result));
// Cursor has not moved
Assert.AreEqual(0, value.Index);
}
public void ParseInt64_TooManyDigits()
{
// We can cope as far as 9223372036854775807, but the trailing 1 causes a failure.
var value = new ValueCursor("92233720368547758071");
value.Move(0);
var parseResult = value.ParseInt64 <string>(out long result);
Assert.IsFalse(parseResult.Success);
Assert.IsInstanceOf <UnparsableValueException>(parseResult.Exception);
Assert.AreEqual(0, value.Index); // Cursor hasn't moved
}
public void ParsePartial_ValidAtEnd()
{
var value = new ValueCursor("x17:30");
value.MoveNext();
value.MoveNext();
var result = SimpleOffsetPattern.ParsePartial(value);
Assert.AreEqual(Offset.FromHoursAndMinutes(17, 30), result.Value);
// Finish just after the value, which in this case is at the end.
Assert.AreEqual(TextCursor.Nul, value.Current);
}
public ParseResult <TResult> ParsePartial(ValueCursor cursor)
{
TBucket bucket = bucketProvider();
foreach (var action in parseActions)
{
ParseResult <TResult> failure = action(cursor, bucket);
if (failure != null)
{
return(failure);
}
}
return(bucket.CalculateValue(usedFields, cursor.Value));
}
public void ParsePartial_ValidInMiddle()
{
var value = new ValueCursor("x17:30y");
value.MoveNext();
value.MoveNext();
// Start already looking at the value to parse
Assert.AreEqual('1', value.Current);
var result = SimpleOffsetPattern.ParsePartial(value);
Assert.AreEqual(Offset.FromHoursAndMinutes(17, 30), result.Value);
// Finish just after the value
Assert.AreEqual('y', value.Current);
}
public ParseResult <T> ParsePartial(ValueCursor cursor)
{
int index = cursor.Index;
foreach (IPartialPattern <T> pattern in parsePatterns)
{
cursor.Move(index);
ParseResult <T> result = pattern.ParsePartial(cursor);
if (result.Success || !result.ContinueAfterErrorWithMultipleFormats)
{
return(result);
}
}
return(ParseResult <T> .NoMatchingFormat);
}
/// <summary>
/// Find the longest match from a given set of candidate strings, updating the index/length of the best value
/// accordingly.
/// </summary>
private static void FindLongestMatch(CompareInfo compareInfo, ValueCursor cursor, IReadOnlyList <string> values, ref int bestIndex, ref int longestMatch)
{
for (int i = 0; i < values.Count; i++)
{
string candidate = values[i];
if (candidate is null || candidate.Length <= longestMatch)
{
continue;
}
if (cursor.MatchCaseInsensitive(candidate, compareInfo, false))
{
bestIndex = i;
longestMatch = candidate.Length;
}
}
}
public void FormatOnly_ParsingFails()
{
var builder = new SteppedPatternBuilder <LocalDate, SampleBucket>(
NodaFormatInfo.InvariantInfo, () => new SampleBucket());
builder.AddFormatAction((date, sb) => sb.Append("Formatted"));
builder.SetFormatOnly();
var pattern = builder.Build(LocalDate.MinIsoValue);
var value = new ValueCursor("xyz");
var result = pattern.ParsePartial(value);
Assert.AreEqual(ParseResult <LocalDate> .FormatOnlyPattern, result);
result = pattern.Parse("xyz");
Assert.AreEqual(ParseResult <LocalDate> .FormatOnlyPattern, result);
}
internal void TestParsePartial()
{
var pattern = CreatePartialPattern();
Assert.IsNull(Message);
var cursor = new ValueCursor("^" + Text + "#");
// Move to the ^
cursor.MoveNext();
// Move to the start of the text
cursor.MoveNext();
var result = pattern.ParsePartial(cursor);
var actualValue = result.Value;
Assert.AreEqual(Value, actualValue);
Assert.AreEqual('#', cursor.Current);
}
public ParseResult <TResult> ParsePartial(ValueCursor cursor)
{
// At the moment we shouldn't get a partial parse for a format-only pattern, but
// let's guard against it for the future.
if (parseActions is null)
{
return(ParseResult <TResult> .FormatOnlyPattern);
}
TBucket bucket = bucketProvider();
foreach (var action in parseActions)
{
ParseResult <TResult>?failure = action(cursor, bucket);
if (failure != null)
{
return(failure);
}
}
return(bucket.CalculateValue(usedFields, cursor.Value));
}
