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 ParseInt64_MinValue()
{
var value = new ValueCursor("-9223372036854775808");
Assert.True(value.MoveNext());
long result;
Assert.IsNull(value.ParseInt64<string>(out result));
Assert.AreEqual(long.MinValue, result);
}
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_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 ParseInt64_Simple()
{
var value = new ValueCursor("56x");
Assert.True(value.MoveNext());
long result;
Assert.IsNull(value.ParseInt64<string>(out result));
Assert.AreEqual(56L, result);
// Cursor ends up post-number
Assert.AreEqual(2, value.Index);
}
// TODO: Tidy this up a *lot*.
public ParseResult <Period> Parse(string text)
{
if (text == null)
{
return(ParseResult <Period> .ArgumentNull("text"));
}
if (text.Length == 0)
{
return(ParseResult <Period> .ValueStringEmpty);
}
ValueCursor valueCursor = new ValueCursor(text);
valueCursor.MoveNext();
if (valueCursor.Current != 'P')
{
return(ParseResult <Period> .MismatchedCharacter(valueCursor, 'P'));
}
bool inDate = true;
PeriodBuilder builder = new PeriodBuilder();
PeriodUnits unitsSoFar = 0;
while (valueCursor.MoveNext())
{
long unitValue;
if (inDate && valueCursor.Current == 'T')
{
inDate = false;
continue;
}
bool negative = valueCursor.Current == '-';
var failure = valueCursor.ParseInt64 <Period>(out unitValue);
if (failure != null)
{
return(failure);
}
if (valueCursor.Length == valueCursor.Index)
{
return(ParseResult <Period> .EndOfString(valueCursor));
}
// Various failure cases:
// - Repeated unit (e.g. P1M2M)
// - Time unit is in date part (e.g. P5M)
// - Date unit is in time part (e.g. PT1D)
// - Unit is in incorrect order (e.g. P5D1Y)
// - Unit is invalid (e.g. P5J)
// - Unit is missing (e.g. P5)
PeriodUnits unit;
switch (valueCursor.Current)
{
case 'Y': unit = PeriodUnits.Years; break;
case 'M': unit = inDate ? PeriodUnits.Months : PeriodUnits.Minutes; break;
case 'W': unit = PeriodUnits.Weeks; break;
case 'D': unit = PeriodUnits.Days; break;
case 'H': unit = PeriodUnits.Hours; break;
case 'S': unit = PeriodUnits.Seconds; break;
case ',':
case '.': unit = PeriodUnits.Ticks; break; // Special handling below
default: return(InvalidUnit(valueCursor, valueCursor.Current));
}
if ((unit & unitsSoFar) != 0)
{
return(RepeatedUnit(valueCursor, valueCursor.Current));
}
// This handles putting months before years, for example. Less significant units
// have higher integer representations.
if (unit < unitsSoFar)
{
return(MisplacedUnit(valueCursor, valueCursor.Current));
}
// The result of checking "there aren't any time units in this unit" should be
// equal to "we're still in the date part".
if ((unit & PeriodUnits.AllTimeUnits) == 0 != inDate)
{
return(MisplacedUnit(valueCursor, valueCursor.Current));
}
// Seen a . or , which need special handling.
if (unit == PeriodUnits.Ticks)
{
// Check for already having seen seconds, e.g. PT5S0.5
if ((unitsSoFar & PeriodUnits.Seconds) != 0)
{
return(MisplacedUnit(valueCursor, valueCursor.Current));
}
builder.Seconds = unitValue;
if (!valueCursor.MoveNext())
{
return(ParseResult <Period> .MissingNumber(valueCursor));
}
int totalTicks;
// Can cope with at most 9999999 ticks
if (!valueCursor.ParseFraction(7, 7, out totalTicks, false))
{
return(ParseResult <Period> .MissingNumber(valueCursor));
}
// Use whether or not the seconds value was negative (even if 0)
// as the indication of whether this value is negative.
if (negative)
{
totalTicks = -totalTicks;
}
builder.Milliseconds = (totalTicks / NodaConstants.TicksPerMillisecond) % NodaConstants.MillisecondsPerSecond;
builder.Ticks = totalTicks % NodaConstants.TicksPerMillisecond;
if (valueCursor.Current != 'S')
{
return(ParseResult <Period> .MismatchedCharacter(valueCursor, 'S'));
}
if (valueCursor.MoveNext())
{
return(ParseResult <Period> .ExpectedEndOfString(valueCursor));
}
return(ParseResult <Period> .ForValue(builder.Build()));
}
builder[unit] = unitValue;
unitsSoFar |= unit;
}
if (unitsSoFar == 0)
{
return(ParseResult <Period> .ForInvalidValue(valueCursor, Messages.Parse_EmptyPeriod));
}
return(ParseResult <Period> .ForValue(builder.Build()));
}
public ParseResult <Period> Parse(string text)
{
if (text == null)
{
return(ParseResult <Period> .ArgumentNull("text"));
}
if (text.Length == 0)
{
return(ParseResult <Period> .ValueStringEmpty);
}
ValueCursor valueCursor = new ValueCursor(text);
valueCursor.MoveNext();
if (valueCursor.Current != 'P')
{
return(ParseResult <Period> .MismatchedCharacter(valueCursor, 'P'));
}
bool inDate = true;
PeriodBuilder builder = new PeriodBuilder();
PeriodUnits unitsSoFar = 0;
while (valueCursor.MoveNext())
{
long unitValue;
if (inDate && valueCursor.Current == 'T')
{
inDate = false;
continue;
}
var failure = valueCursor.ParseInt64 <Period>(out unitValue);
if (failure != null)
{
return(failure);
}
if (valueCursor.Length == valueCursor.Index)
{
return(ParseResult <Period> .EndOfString(valueCursor));
}
// Various failure cases:
// - Repeated unit (e.g. P1M2M)
// - Time unit is in date part (e.g. P5M)
// - Date unit is in time part (e.g. PT1D)
// - Unit is in incorrect order (e.g. P5D1Y)
// - Unit is invalid (e.g. P5J)
// - Unit is missing (e.g. P5)
PeriodUnits unit;
switch (valueCursor.Current)
{
case 'Y': unit = PeriodUnits.Years; break;
case 'M': unit = inDate ? PeriodUnits.Months : PeriodUnits.Minutes; break;
case 'W': unit = PeriodUnits.Weeks; break;
case 'D': unit = PeriodUnits.Days; break;
case 'H': unit = PeriodUnits.Hours; break;
case 'S': unit = PeriodUnits.Seconds; break;
case 's': unit = PeriodUnits.Milliseconds; break;
case 't': unit = PeriodUnits.Ticks; break;
default: return(InvalidUnit(valueCursor, valueCursor.Current));
}
if ((unit & unitsSoFar) != 0)
{
return(RepeatedUnit(valueCursor, valueCursor.Current));
}
// This handles putting months before years, for example. Less significant units
// have higher integer representations.
if (unit < unitsSoFar)
{
return(MisplacedUnit(valueCursor, valueCursor.Current));
}
// The result of checking "there aren't any time units in this unit" should be
// equal to "we're still in the date part".
if ((unit & PeriodUnits.AllTimeUnits) == 0 != inDate)
{
return(MisplacedUnit(valueCursor, valueCursor.Current));
}
builder[unit] = unitValue;
unitsSoFar |= unit;
}
return(ParseResult <Period> .ForValue(builder.Build()));
}
