public void TestFromCenturyToCenturyOrdinal()
{
string input = @"Late eighth to early ninth century";
IYearSpan expected = new YearSpan(760, 840, input);
compare(input, expected, EnumLanguage.EN);
}
//private IYearSpanParser parser = new YearSpanParser();
private void compare(String input, IYearSpan expected, EnumLanguage language)
{
//IInterval<int> result = parser.Parse(input);
IYearSpan result = YearSpan.Parse(input, language);
compare(result, expected);
}
public void TestCardinalCenturyBC()
{
string input = @"5th CENTURY BC";
IYearSpan expected = new YearSpan(-500, -401, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestMonthYear()
{
string input = @"January 1900";
IYearSpan expected = new YearSpan(1900, 1900, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestOrdinalCenturyLateAD()
{
string input = @"LATE FIFTH CENTURY AD";
IYearSpan expected = new YearSpan(460, 500, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestCardinalCenturyAD()
{
string input = @"5TH CENTURY AD";
IYearSpan expected = new YearSpan(401, 500, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestNamedPeriod()
{
string input = @"Georgian";
IYearSpan expected = new YearSpan(1714, 1837, input, "en");
compare(input, expected, EnumLanguage.EN);
}
public void TestOrdinalCenturyEarlyBC()
{
string input = @"EARLY FIFTH CENTURY BC";
IYearSpan expected = new YearSpan(-500, -460, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestCircaYearBP()
{
string input = @"C. 1521 BP";
IYearSpan expected = new YearSpan(429, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestNonMatchReturnsMaxInt()
{
string input = @"abc/xyz";
IYearSpan expected = new YearSpan(int.MaxValue, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestCircaYearAD()
{
string input = @"C. 1521 AD";
IYearSpan expected = new YearSpan(1521, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestYearBC_IT()
{
string input = @"1521 a.C.";
IYearSpan expected = new YearSpan(-1521, input);
compare(input, expected, EnumLanguage.IT);
}
public void TestYearBC()
{
string input = @"1521 BC";
IYearSpan expected = new YearSpan(-1521, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestOrdinalCenturyBP()
{
string input = @"FIFTH CENTURY BP";
IYearSpan expected = new YearSpan(1451, 1550, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestNamedPeriod_IT()
{
string input = @"Mesolitico";
IYearSpan expected = new YearSpan(-9999, -5000, input, "it");
compare(input, expected, EnumLanguage.IT);
}
public void TestOrdinaCenturyEarlyAD()
{
string input = @"EARLY FIFTH CENTURY AD";
IYearSpan expected = new YearSpan(401, 440, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestDecade_EN()
{
string input = @"1930s";
IYearSpan expected = new YearSpan(1930, 1939, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestOrdinalCenturyMidBC()
{
string input = @"MID FIFTH CENTURY BC";
IYearSpan expected = new YearSpan(-470, -430, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestDecade_IT()
{
string input = @"Intorno al decennio 1850esimo";
IYearSpan expected = new YearSpan(1850, 1859, input);
compare(input, expected, EnumLanguage.IT);
}
public void TestOrdinalCenturyLateBC()
{
string input = @"LATE FIFTH CENTURY BC";
IYearSpan expected = new YearSpan(-440, -401, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestCircaDotDecadeApostrophe()
{
string input = @"C. 1930's";
IYearSpan expected = new YearSpan(1930, 1939, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestYear2digit()
{
string input = @"15";
IYearSpan expected = new YearSpan(15, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestFromCenturyToCenturyAD()
{
string input = @"4th-5th century";
IYearSpan expected = new YearSpan(301, 500, input);
compare(input, expected, EnumLanguage.EN);
}
public void Test2DigitMaxYear()
{
string input = @"1521-27";
IYearSpan expected = new YearSpan(1521, 1527, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestCardinalMillenniumBC()
{
string input = @"1st millennium BC";
IYearSpan expected = new YearSpan(-1, -1000, input);
compare(input, expected, EnumLanguage.EN);
}
public void TestCardinalCenturyBC_IT()
{
string input = @"sec. VIII a.C.";
IYearSpan expected = new YearSpan(-800, -701, input);
IYearSpan result = YearSpan.Parse(input, EnumLanguage.IT);
compare(result, expected);
}
public void Test1DigitMaxYear()
{
string input = @"1521-7";
IYearSpan expected = new YearSpan(1521, 1527, input);
//IInterval<int> result = parser.Parse(input);
IYearSpan result = YearSpan.Parse(input, EnumLanguage.EN);
compare(expected, result);
}
public void TestArrayOfInput()
{
string[] input = { @"5th CENTURY", @"6th CENTURY" };
IYearSpan[] expected =
{
new YearSpan(401, 500, input[0]),
new YearSpan(501, 600, input[1])
};
IYearSpan[] result = YearSpan.Parse(input, EnumLanguage.EN);
CollectionAssert.AreEqual(expected, result);
}
// NEW: 09/05/2017 bringing parser operations into the YearSpan class itself
// TODO: throw exceptions:
// ArgumentNullException -> s is null
// ?FormatException -> s is not in the correct format (how can we know that?)
// ?OverflowException -> a year represents a number less than Int.MinValue or greater than Int.MaxValue
/// <summary>Parse a <c>YearSpan</c> from a <c>String</c> input value</summary>
/// <param name="s">Input <c>String</c> to be parsed</param>
/// <returns><c>YearSpan</c></returns>
/// <exception cref="System.ArgumentNullException">Thrown when s is null</exception>
public static IYearSpan Parse(string s, EnumLanguage language)
{
if (s == null)
{
throw new System.ArgumentNullException("s", "null input value");
}
// IEnumerable<IYearSpanParser> yearSpanParsers = getParserInstances();
IYearSpan span;
// try each matcher until first match (done this way rather than reflection so we control the order of matching)
if (Rx.FromYearToYear.IsMatch(s, language))
{
span = Rx.FromYearToYear.Match(s, language);
}
else if (Rx.FromCenturyToCentury.IsMatch(s, language))
{
span = Rx.FromCenturyToCentury.Match(s, language);
}
else if (Rx.FromCenturyToCenturyOrdinal.IsMatch(s, language))
{
span = Rx.FromCenturyToCenturyOrdinal.Match(s, language);
}
else if (Rx.Decade.IsMatch(s, language))
{
span = Rx.Decade.Match(s, language);
}
else if (Rx.MonthYear.IsMatch(s, language))
{
span = Rx.MonthYear.Match(s, language);
}
else if (Rx.CardinalCentury.IsMatch(s, language))
{
span = Rx.CardinalCentury.Match(s, language);
}
else if (Rx.OrdinalCentury.IsMatch(s, language))
{
span = Rx.OrdinalCentury.Match(s, language);
}
else if (Rx.OrdinalMillennium.IsMatch(s, language))
{
span = Rx.OrdinalMillennium.Match(s, language);
}
else if (Rx.CardinalMillennium.IsMatch(s, language))
{
span = Rx.CardinalMillennium.Match(s, language);
}
else if (Rx.SeasonYear.IsMatch(s, language))
{
span = Rx.SeasonYear.Match(s, language);
}
else if (Rx.SingleYear.IsMatch(s, language))
{
span = Rx.SingleYear.Match(s, language);
}
else if (Rx.YearWithTolerance.IsMatch(s, language))
{
span = Rx.YearWithTolerance.Match(s, language);
}
else if (Rx.DateTimeMatch.IsMatch(s, language))
{
span = Rx.DateTimeMatch.Match(s, language);
}
//else if (Rx.NamedPeriod.IsMatch(s, language)) span = Rx.NamedPeriod.Match(s, language);
else if (Rx.Lookup <NamedPeriod> .IsMatch(s, language))
{
span = (IYearSpan)Rx.Lookup <NamedPeriod> .Match(s, language);
span.label = s;
span.language = language;
span.note = "RxLookup"; // these properties are not populated by (generic) Rx.Lookup
}
//else if (NamedPeriod.IsMatch(s, language)) span = (IYearSpan)NamedPeriod.Match(s, language);
//else if (Rx.LastChance.IsMatch(s, language)) span = Rx.LastChance.Match(s, language);
else
{
span = new YearSpan(0, s); // no match? zero year span returned
}
// try each available parser until first match
/*foreach (IMatcher<IYearSpan> p in parserInstances)
* {
* IYearSpan span = null;
* try
* {
* span = p.Match(s, language);
* }
* catch (Exception e)
* {
* System.Diagnostics.Debug.WriteLine(e.Message);
* }
* if (span != null) return span;
* }*/
/* IList<Type> types = getMatcherTypes();
* foreach (Type t in types)
* {
* IYearSpan span = null;
* try
* {
* IMatcher<IYearSpan> m = (IMatcher<IYearSpan>)t;
* span = m.Match(s, language);
* }
* catch (Exception e)
* {
* System.Diagnostics.Debug.WriteLine(e.Message);
* }
* if (span != null) return span;
* } */
/*foreach (IYearSpanParser p in parserInstances)
* {
* IYearSpan span = p.Parse(s, language);
* if (span != null) return span;
* }*/
return(span);
//return new YearSpan(5,5); //temp
}
