public void holiday_days_span()
{
var dateTimeCulture = new WorkingDayCultureInfo("ko-KR");
var holiday = KO_KRHolidayStrategy.Seolnal;
var startDay = holiday.GetInstance(2015);
//Seol 2015
DateTime day = new DateTime(2015, 2, 18);
do
{
Assert.IsFalse(dateTimeCulture.IsWorkingDay(day), day.ToString() + " shouldn't be a working day");
day = day.AddDays(1);
} while (day <= new DateTime(2015, 2, 20));
//Seol 2016 (with substitute holiday)
day = new DateTime(2016, 2, 7);
do
{
Assert.IsFalse(dateTimeCulture.IsWorkingDay(day), day.ToString() + " shouldn't be a working day");
day = day.AddDays(1);
} while (day <= new DateTime(2015, 2, 10));
//Chuseok 2015 (with substitute holiday)
day = new DateTime(2015, 9, 26);
do
{
Assert.IsFalse(dateTimeCulture.IsWorkingDay(day), day.ToString() + " shouldn't be a working day");
day = day.AddDays(1);
} while (day <= new DateTime(2015, 9, 29));
}
public void provide_custom_strategies()
{
var customWorkingDayCultureInfo = new WorkingDayCultureInfo("CustomTest");
Assert.IsTrue(DateTime.Today.IsWorkingDay(customWorkingDayCultureInfo) == false);
Assert.IsTrue(DateTime.Today.AddDays(1).IsWorkingDay(customWorkingDayCultureInfo) == true);
}
public void assert_holidays_count()
{
var dateTimeCulture = new WorkingDayCultureInfo("fr-CA");
var holidays = dateTimeCulture.Holidays;
Assert.AreEqual(8, holidays.Count());
}
public void are_working_days_on_thursday_and_friday()
{
var dateTimeCulture = new WorkingDayCultureInfo("ar-SA");
Assert.IsFalse(dateTimeCulture.IsWorkingDay(DayOfWeek.Thursday));
Assert.IsFalse(dateTimeCulture.IsWorkingDay(DayOfWeek.Friday));
}
public void IsHoliday_FixedDateColombianHoliday_ReturnsTrue()
{
var workingDayCultureInfo = new WorkingDayCultureInfo("es-CO");
var newYear = new DateTime(2018, 1, 1);
Assert.IsTrue(newYear.IsHoliday(workingDayCultureInfo));
var laboursDay = new DateTime(2018, 5, 1);
Assert.IsTrue(laboursDay.IsHoliday(workingDayCultureInfo));
var independenceDay = new DateTime(2018, 7, 20);
Assert.IsTrue(independenceDay.IsHoliday(workingDayCultureInfo));
var boyacaBattle = new DateTime(2018, 8, 7);
Assert.IsTrue(boyacaBattle.IsHoliday(workingDayCultureInfo));
var immaculateConception = new DateTime(2018, 12, 8);
Assert.IsTrue(immaculateConception.IsHoliday(workingDayCultureInfo));
var christmas = new DateTime(2018, 12, 25);
Assert.IsTrue(christmas.IsHoliday(workingDayCultureInfo));
}
public void CanWorkOn2016()
{
var dateTimeCulture = new WorkingDayCultureInfo("fr-CA");
var holidays = dateTimeCulture.GetHolidaysOfYear(2016);
Assert.IsTrue(holidays.Any());
}
public void IsHoliday_NextMondayColombianHoliday_ReturnsTrue()
{
var workingDayCultureInfo = new WorkingDayCultureInfo("es-CO");
var epiphany = new DateTime(2018, 1, 8);
Assert.IsTrue(epiphany.IsHoliday(workingDayCultureInfo));
var saintJoseph = new DateTime(2018, 3, 19);
Assert.IsTrue(saintJoseph.IsHoliday(workingDayCultureInfo));
var saintPeterAndSaintPaul = new DateTime(2018, 7, 2);
Assert.IsTrue(saintPeterAndSaintPaul.IsHoliday(workingDayCultureInfo));
var virginAssumption = new DateTime(2018, 8, 20);
Assert.IsTrue(virginAssumption.IsHoliday(workingDayCultureInfo));
var raceDay = new DateTime(2018, 10, 15);
Assert.IsTrue(raceDay.IsHoliday(workingDayCultureInfo));
var allSaintsDay = new DateTime(2018, 11, 5);
Assert.IsTrue(allSaintsDay.IsHoliday(workingDayCultureInfo));
var independenceOfCartagena = new DateTime(2018, 11, 12);
Assert.IsTrue(independenceOfCartagena.IsHoliday(workingDayCultureInfo));
}
public void IsHoliday_EasterColombianHoliday_ReturnsTrue()
{
var workingDayCultureInfo = new WorkingDayCultureInfo("es-CO");
var palmSunday = new DateTime(2018, 3, 25);
Assert.IsTrue(palmSunday.IsHoliday(workingDayCultureInfo));
var maundyThursday = new DateTime(2018, 3, 29);
Assert.IsTrue(maundyThursday.IsHoliday(workingDayCultureInfo));
var goodFriday = new DateTime(2018, 3, 30);
Assert.IsTrue(goodFriday.IsHoliday(workingDayCultureInfo));
var easter = new DateTime(2018, 4, 1);
Assert.IsTrue(easter.IsHoliday(workingDayCultureInfo));
var ascension = new DateTime(2018, 5, 14);
Assert.IsTrue(ascension.IsHoliday(workingDayCultureInfo));
var corpusChristi = new DateTime(2018, 6, 4);
Assert.IsTrue(corpusChristi.IsHoliday(workingDayCultureInfo));
var sacredHeart = new DateTime(2018, 6, 11);
Assert.IsTrue(sacredHeart.IsHoliday(workingDayCultureInfo));
}
public void can_get_stratery()
{
var dateTimeCulture = new WorkingDayCultureInfo("fr-CA");
var strategy = dateTimeCulture.LocateHolidayStrategy(dateTimeCulture.Name);
Assert.AreEqual(typeof(FR_CAHolidayStrategy), strategy.GetType());
}
public void can_provide_custom_locator_holiday_dayOfWeek_strategy()
{
var mockHolidayStrategy = Substitute.For <IHolidayStrategy>();
mockHolidayStrategy.IsHoliDay(Arg.Any <DateTime>()).Returns(true);
var mockDayOfWeekStartegy = Substitute.For <IWorkingDayOfWeekStrategy>();
mockDayOfWeekStartegy.IsWorkingDay(Arg.Any <DayOfWeek>()).Returns(true);
WorkingDayCultureInfo workingdayCultureInfo = new WorkingDayCultureInfo()
{
LocateHolidayStrategy = (n) => {
return(mockHolidayStrategy);
},
LocateWorkingDayOfWeekStrategy = (n) => {
return(mockDayOfWeekStartegy);
}
};
DateTime marchFirst = new DateTime(1991, 3, 1);
Assert.IsTrue(marchFirst.IsHoliday(workingdayCultureInfo));
Assert.IsFalse(marchFirst.IsWorkingDay(workingdayCultureInfo));
mockHolidayStrategy.Received().IsHoliDay(marchFirst);
mockDayOfWeekStartegy.Received().IsWorkingDay(marchFirst.DayOfWeek);
}
public void can_locate_by_name()
{
string name = "pt-PT";
WorkingDayCultureInfo workingdayCultureInfo = new WorkingDayCultureInfo(name);
Assert.IsTrue(name == workingdayCultureInfo.Name);
Assert.IsInstanceOf<PT_PTHolidayStrategy>(workingdayCultureInfo.LocateHolidayStrategy(name));
}
public void are_working_days_on_sunday()
{
var dateTimeCulture = new WorkingDayCultureInfo("tr-TR");
Assert.IsTrue(dateTimeCulture.IsWorkingDay(DayOfWeek.Saturday));
Assert.IsFalse(dateTimeCulture.IsWorkingDay(DayOfWeek.Sunday));
}
static void Main(string[] args)
{
//Arrange
var culture = new WorkingDayCultureInfo("en-US");
var startDate = new DateTime(2018, 5, 1);
int n = 10;
List <int> list = new List <int>(n);
for (int i = 0; i < n; i++)
{
list.Add(i);
}
//Act
Parallel.ForEach(list, (i) =>
{
try
{
startDate.AddWorkingDays(i, culture);
}
catch (Exception exp) { }
});
var midsummerDay = new NthDayOfWeekAfterDayHoliday("Midsummer Day", 1, DayOfWeek.Saturday, 6, 20);
Parallel.ForEach(list, (i) =>
{
try
{
midsummerDay.GetInstance(1900 + i);
}
catch (Exception exp) { }
});
}
public void can_locate_default_strategies()
{
string name = "foo";
WorkingDayCultureInfo workingdayCultureInfo = new WorkingDayCultureInfo(name);
Assert.IsTrue(name == workingdayCultureInfo.Name);
Assert.IsInstanceOf<DefaultHolidayStrategy>(workingdayCultureInfo.LocateHolidayStrategy(name));
Assert.IsInstanceOf<DefaultWorkingDayOfWeekStrategy>(workingdayCultureInfo.LocateWorkingDayOfWeekStrategy(name));
}
public void Holidays_ColombianCulture_Counts20PerYear()
{
var workingDayCultureInfo = new WorkingDayCultureInfo("es-CO");
var holidays = workingDayCultureInfo.Holidays;
Assert.AreEqual(20, holidays.Count());
}
public void can_use_reginal_holidays_Porto()
{
var cultureInfo = new WorkingDayCultureInfo("pt-PT", PortugalRegion.Porto);
DateTime stJoao = new DateTime(2017, 6, 24);
Assert.AreEqual(stJoao.DayOfWeek, DayOfWeek.Saturday);
Assert.IsTrue(stJoao.IsHoliday(cultureInfo));
}
public void can_use_reginal_holidays_Lisboa()
{
var cultureInfo = new WorkingDayCultureInfo("pt-PT", PortugalRegion.Lisboa);
DateTime stAntonio = new DateTime(2017, 6, 13);
Assert.AreEqual(stAntonio.DayOfWeek, DayOfWeek.Tuesday);
Assert.IsTrue(stAntonio.IsHoliday(cultureInfo));
}
public void can_get_strateryies()
{
var dateTimeCulture = new WorkingDayCultureInfo("ar-SA");
var holidaysStrategy = dateTimeCulture.LocateHolidayStrategy(dateTimeCulture.Name);
Assert.AreEqual(typeof(AR_SAHolidayStrategy), holidaysStrategy.GetType());
var workingDaysStrategy = dateTimeCulture.LocateWorkingDayOfWeekStrategy(dateTimeCulture.Name);
Assert.AreEqual(typeof(AR_SAWorkingDayOfWeekStrategy), workingDaysStrategy.GetType());
}
public void can_locate_by_name()
{
string name = "pt-PT";
WorkingDayCultureInfo workingdayCultureInfo = new WorkingDayCultureInfo(name);
Assert.IsTrue(name == workingdayCultureInfo.Name);
Assert.IsInstanceOf <PT_PTHolidayStrategy>(workingdayCultureInfo.LocateHolidayStrategy(name, null));
}
public void can_locate_by_culture_info()
{
string name = "pt-PT";
System.Threading.Thread.CurrentThread.CurrentCulture = new CultureInfo(name);
WorkingDayCultureInfo workingdayCultureInfo = new WorkingDayCultureInfo();
Assert.IsTrue(name == workingdayCultureInfo.Name);
Assert.IsInstanceOf<PT_PTHolidayStrategy>(workingdayCultureInfo.LocateHolidayStrategy(name));
}
public void AddWorkingDays_MultipleThreads_CanCalculate()
{
//Arrange
var culture = new WorkingDayCultureInfo("en-US");
var startDate = new DateTime(2018, 5, 1);
//Act
Parallel.ForEach(Enumerable.Range(1, 10), (i) => startDate.AddWorkingDays(i, culture));
}
public void can_use_reginal_holidays_CasteloBranco()
{
var cultureInfo = new WorkingDayCultureInfo("pt-PT", PortugalRegion.CasteloBranco);
// not using 2017 since it's 25th April, same day as another national Holiday
var sraMerculesDay = new DateTime(2016, 4, 5);
Assert.AreEqual(sraMerculesDay.DayOfWeek, DayOfWeek.Tuesday);
Assert.IsTrue(sraMerculesDay.IsHoliday(cultureInfo));
}
public void can_locate_default_strategies()
{
string name = "foo";
WorkingDayCultureInfo workingdayCultureInfo = new WorkingDayCultureInfo(name);
Assert.IsTrue(name == workingdayCultureInfo.Name);
Assert.IsInstanceOf <DefaultHolidayStrategy>(workingdayCultureInfo.LocateHolidayStrategy(name));
Assert.IsInstanceOf <DefaultWorkingDayOfWeekStrategy>(workingdayCultureInfo.LocateWorkingDayOfWeekStrategy(name));
}
public void revert_to_national_holidays_on_unknown_region()
{
var cultureInfo = new WorkingDayCultureInfo("pt-PT", "non-existing-region");
// not using 2017 since it's 25th April, same day as another national Holiday
var sraMerculesDay = new DateTime(2017, 4, 25);
Assert.AreEqual(sraMerculesDay.DayOfWeek, DayOfWeek.Tuesday);
Assert.IsTrue(sraMerculesDay.IsHoliday(cultureInfo));
}
public void CanGetChineseHolidaysListIn2016()
{
var cultureInfo = new WorkingDayCultureInfo("zh-CN");
Assert.IsNotNull(cultureInfo);
var holidays = cultureInfo.GetHolidaysOfYear(2016);
Assert.AreEqual(7, holidays.Count());
}
public void recomended_calculation()
{
var workingDayCultureInfo = new WorkingDayCultureInfo("pt-PT");
var friday = new DateTime(2011, 5, 13); // A friday
var friday_plus_two_working_days = friday.AddWorkingDays(2, workingDayCultureInfo); // friday + 2 working days
Assert.IsTrue(friday_plus_two_working_days == friday.AddDays(4));
Assert.IsTrue(friday_plus_two_working_days.DayOfWeek == DayOfWeek.Tuesday);
}
public void CanGetIndianHolidaysListIn2017()
{
var cultureInfo = new WorkingDayCultureInfo("en-IN");
Assert.IsNotNull(cultureInfo);
var holidays = cultureInfo.GetHolidaysOfYear(2017);
Assert.AreEqual(5, holidays.Count());
}
public void assert_holidays_on_weekend_observed_on_monday()
{
var dateTimeCulture = new WorkingDayCultureInfo("fr-CA");
// 01-07-2012 Canada Day on a Sunday
var mondayAfterCanadaDay = new DateTime(2012, 07, 02);
Assert.AreEqual(DayOfWeek.Monday, mondayAfterCanadaDay.DayOfWeek);
Assert.IsFalse(mondayAfterCanadaDay.IsWorkingDay(dateTimeCulture));
}
public void ColumbusDayNotAnHoliday()
{
var date = new DateTime(2020, 10, 12); //second monday on October
var workingDayCultureInfo = new MyCustomCultureInfo();
var defaultWorkingDayCultureInfo = new WorkingDayCultureInfo("en-US");
Assert.IsFalse(date.IsHoliday(workingDayCultureInfo));
Assert.IsTrue(date.IsHoliday(defaultWorkingDayCultureInfo));
}
public void can_locate_by_culture_info()
{
string name = "pt-PT";
System.Threading.Thread.CurrentThread.CurrentCulture = new CultureInfo(name);
WorkingDayCultureInfo workingdayCultureInfo = new WorkingDayCultureInfo();
Assert.IsTrue(name == workingdayCultureInfo.Name);
Assert.IsInstanceOf <PT_PTHolidayStrategy>(workingdayCultureInfo.LocateHolidayStrategy(name));
}
public void can_get_strateryies()
{
var dateTimeCulture = new WorkingDayCultureInfo("ko-KR");
var holidaysStrategy = dateTimeCulture.LocateHolidayStrategy(dateTimeCulture.Name, null);
Assert.AreEqual(typeof(KO_KRHolidayStrategy), holidaysStrategy.GetType());
var workingDaysStrategy = dateTimeCulture.LocateWorkingDayOfWeekStrategy(dateTimeCulture.Name, null);
Assert.AreEqual(typeof(DefaultWorkingDayOfWeekStrategy), workingDaysStrategy.GetType());
}
public void can_get_strateryies()
{
var dateTimeCulture = new WorkingDayCultureInfo("ar-SA");
var holidaysStrategy = dateTimeCulture.LocateHolidayStrategy(dateTimeCulture.Name);
Assert.AreEqual(typeof(AR_SAHolidayStrategy), holidaysStrategy.GetType());
var workingDaysStrategy = dateTimeCulture.LocateWorkingDayOfWeekStrategy(dateTimeCulture.Name);
Assert.AreEqual(typeof(AR_SAWorkingDayOfWeekStrategy), workingDaysStrategy.GetType());
}
public void can_get_strategies()
{
var dateTimeCulture = new WorkingDayCultureInfo("tr-TR");
var holidaysStrategy = dateTimeCulture.LocateHolidayStrategy(dateTimeCulture.Name, null);
Assert.AreEqual(typeof(TurkishHolidayStrategy), holidaysStrategy.GetType());
var workingDaysStrategy = dateTimeCulture.LocateWorkingDayOfWeekStrategy(dateTimeCulture.Name, null);
Assert.AreEqual(typeof(TurkishWorkingDayStrategy), workingDaysStrategy.GetType());
}
/// <summary>
/// Calculates the Workingdays in the range <paramref name="from"/> / <paramref name="to"/>
/// </summary>
/// <param name="from">The starting day.</param>
/// <param name="to">The end day.</param>
/// <param name="workingDayCultureInfo">The culture of working days to be used in the calculation. See <seealso cref="WorkingDayCultureInfo"/> for more information.</param>
/// <returns>the number of Workingdays in the range <paramref name="from"/> / <paramref name="to"/></returns>
public static int GetWorkingDays(this DateTime from, DateTime to, WorkingDayCultureInfo workingDayCultureInfo)
{
var innerFrom = from < to ? from : to;
var innerTo = from < to ? to : from;
var dayCount = (innerTo.Date - innerFrom.Date).Days;
var days = Enumerable.Range(0, dayCount).Select(d => innerFrom.AddDays(d));
return(days.Count(w => w.IsWorkingDay(workingDayCultureInfo)));
}
public void can_generate_holidays()
{
var dateTimeCulture = new WorkingDayCultureInfo("ar-SA");
var year = 2000;
do
{
var holidays = dateTimeCulture.GetHolidaysOfYear(year);
Assert.Greater(holidays.Count(), 0);
year++;
} while (year < 2020);
}
public void check_working_day()
{
var ptWorkingDayCultureInfo = new WorkingDayCultureInfo("pt-PT");
var carnationRevolution = new DateTime(2011, 4, 25);
var nextDay = carnationRevolution.AddDays(1);
Assert.IsTrue(carnationRevolution.IsWorkingDay(ptWorkingDayCultureInfo) == false);
Assert.IsTrue(carnationRevolution.DayOfWeek == DayOfWeek.Monday);
Assert.IsTrue(nextDay.IsWorkingDay(ptWorkingDayCultureInfo));
Assert.IsTrue(nextDay.DayOfWeek == DayOfWeek.Tuesday);
}
public void get_year_since_2013_holidays_in_portugal()
{
var portugalWorkingDayCultureInfo = new WorkingDayCultureInfo("pt-PT");
var today = new DateTime(2013, 2, 1);
var holidays = today.AllYearHolidays(portugalWorkingDayCultureInfo);
Assert.IsTrue(holidays.Count == 9, "expecting 9 holidays but got {0}", holidays.Count);
foreach (DateTime holidayDate in holidays.Keys) {
var holiday = holidays[holidayDate];
Assert.IsTrue(holidayDate.IsWorkingDay(portugalWorkingDayCultureInfo) == false, "holiday {0} shouln't be working day in Portugal", holiday.Name);
}
}
public void picks_a_holiday_when_two_holidays_occur_on_the_same_date()
{
/* In 2005, Ascension day was on the fifth of May. That year, the fifth of may was
* also a national public holiday (liberation day). The holiday picker should not
* fail, but it is arbritrary which one of the holidays it should return, so either
* one is OK. HolidayStrategyBase.BuildObservancesMap should survive this.
*/
var inTheNetherlands = new WorkingDayCultureInfo("nl-NL");
var fifthOfMay = new DateTime(2005, 5, 5);
Assert.That(fifthOfMay.IsHoliday(inTheNetherlands));
}
public void can_provide_custom_locator_dayOfWeek_strategy()
{
var mockDayOfWeekStartegy = Substitute.For<IWorkingDayOfWeekStrategy>();
mockDayOfWeekStartegy.IsWorkingDay(Arg.Any<DayOfWeek>()).Returns(false);
WorkingDayCultureInfo workingdayCultureInfo = new WorkingDayCultureInfo()
{
LocateWorkingDayOfWeekStrategy = (n) => { return mockDayOfWeekStartegy; }
};
DateTime aThursday = new DateTime(2011, 5, 12);
Assert.IsFalse(aThursday.IsWorkingDay(workingdayCultureInfo));
Assert.IsFalse(aThursday.IsHoliday(workingdayCultureInfo));
mockDayOfWeekStartegy.Received().IsWorkingDay(aThursday.DayOfWeek);
}
public void get_us_holidays_in_2015_passes()
{
var usWorkingDayCultureInfo = new WorkingDayCultureInfo("en-US");
var today = new DateTime(2015, 1, 1);
var holidays = today.AllYearHolidays(usWorkingDayCultureInfo);
Assert.IsTrue(holidays.Count == 10, "expecting 10 holidays but got {0}", holidays.Count);
foreach (DateTime holidayDate in holidays.Keys)
{
var holiday = holidays[holidayDate];
Assert.IsTrue(holidayDate.IsWorkingDay(usWorkingDayCultureInfo) == false,
"holiday {0} shouln't be working day in US", holiday.Name);
}
}
public void can_provide_custom_locator_holiday_dayOfWeek_strategy()
{
var mockHolidayStrategy = Substitute.For<IHolidayStrategy>();
mockHolidayStrategy.IsHoliDay(Arg.Any<DateTime>()).Returns(true);
var mockDayOfWeekStartegy = Substitute.For<IWorkingDayOfWeekStrategy>();
mockDayOfWeekStartegy.IsWorkingDay(Arg.Any<DayOfWeek>()).Returns(true);
WorkingDayCultureInfo workingdayCultureInfo = new WorkingDayCultureInfo()
{
LocateHolidayStrategy = (n) => { return mockHolidayStrategy; },
LocateWorkingDayOfWeekStrategy = (n) => { return mockDayOfWeekStartegy; }
};
DateTime marchFirst = new DateTime(1991, 3, 1);
Assert.IsTrue(marchFirst.IsHoliday(workingdayCultureInfo));
Assert.IsFalse(marchFirst.IsWorkingDay(workingdayCultureInfo));
mockHolidayStrategy.Received().IsHoliDay(marchFirst);
mockDayOfWeekStartegy.Received().IsWorkingDay(marchFirst.DayOfWeek);
}
public void holiday_days_span()
{
var dateTimeCulture = new WorkingDayCultureInfo("ar-SA");
var holiday = AR_SAHolidayStrategy.EndOfHajj;
var startDay = holiday.GetInstance(2012);
//Eid-al-Fitr
DateTime day = new DateTime(2012, 8, 19);
do {
Assert.IsFalse(dateTimeCulture.IsWorkingDay(day), day.ToString() + " shouldn't be a working day");
day = day.AddDays(1);
} while (day <= new DateTime(2012, 8, 25));
//Eid-al-Adha
day = new DateTime(2012, 10, 26);
do {
Assert.IsFalse(dateTimeCulture.IsWorkingDay(day), day.ToString() + " shouldn't be a working day");
day = day.AddDays(1);
} while (day <= new DateTime(2012, 10, 31));
}
public void provide_custom_strategies()
{
var customWorkingDayCultureInfo = new WorkingDayCultureInfo("CustomTest");
Assert.IsTrue(DateTime.Today.IsWorkingDay(customWorkingDayCultureInfo) == false);
Assert.IsTrue(DateTime.Today.AddDays(1).IsWorkingDay(customWorkingDayCultureInfo) == true);
}
public void are_working_days_on_thursday_and_friday()
{
var dateTimeCulture = new WorkingDayCultureInfo("ar-SA");
Assert.IsFalse(dateTimeCulture.IsWorkingDay(DayOfWeek.Thursday));
Assert.IsFalse(dateTimeCulture.IsWorkingDay(DayOfWeek.Friday));
}
public void recomended_calculation()
{
var workingDayCultureInfo = new WorkingDayCultureInfo("pt-PT");
var friday = new DateTime(2011, 5, 13); // A friday
var friday_plus_two_working_days = friday.AddWorkingDays(2, workingDayCultureInfo); // friday + 2 working days
Assert.IsTrue(friday_plus_two_working_days == friday.AddDays(4));
Assert.IsTrue(friday_plus_two_working_days.DayOfWeek == DayOfWeek.Tuesday);
}
/// <summary>
/// Retrieves the holidays that have and are still ocouring on the <paramref name="day" /> year, using the default <seealso cref="IWorkingDayCultureInfo"/>.
/// </summary>
/// <param name="day">The day used to gat the year from.</param>
/// <returns>Returns a dictionary with the instance of the holiday observed on the year, and the holiday that gave it the observance.</returns>
public static IDictionary<DateTime, Holiday> AllYearHolidays(this DateTime day)
{
var workingDayCultureInfo = new WorkingDayCultureInfo();
return AllYearHolidays(day, workingDayCultureInfo);
}
/// <summary>
/// Checks if a specific day is an holiday day, using the default <seealso cref="IWorkingDayCultureInfo"/>, desregarding
/// the day of the week.
/// </summary>
/// <param name="day">The day from calendar to check</param>
/// <returns></returns>
public static bool IsWorkingDay(this DateTime day)
{
var workingDayCultureInfo = new WorkingDayCultureInfo();
return IsWorkingDay(day, workingDayCultureInfo);
}
/// <summary>
/// Calculates the Workingdays in the range <paramref name="from"/> / <paramref name="to"/>
/// </summary>
/// <param name="from">The starting day.</param>
/// <param name="to">The end day.</param>
/// <param name="workingDayCultureInfo">The culture of working days to be used in the calculation. See <seealso cref="WorkingDayCultureInfo"/> for more information.</param>
/// <returns>the number of Workingdays in the range <paramref name="from"/> / <paramref name="to"/></returns>
public static int GetWorkingDays(DateTime from, DateTime to, WorkingDayCultureInfo workingDayCultureInfo)
{
var innerFrom = from < to ? from : to;
var innerTo = from < to ? to : from;
var dayCount = (innerTo.Date - innerFrom.Date).Days;
var days = Enumerable.Range(0, dayCount).Select(d => innerFrom.AddDays(d));
return days.Count(w => w.IsWorkingDay(workingDayCultureInfo));
}
public void holidays()
{
var ptWorkingDayCultureInfo = new WorkingDayCultureInfo("pt-PT");
var enWorkingDayCultureInfo = new WorkingDayCultureInfo("default");
var thursday = new DateTime(2011, 4, 21); // A thursday
var thursday_plus_two_working_days_pt = thursday.AddWorkingDays(2, ptWorkingDayCultureInfo); // friday + 2 working days on PT
var thursday_plus_two_working_days_en = thursday.AddWorkingDays(2, enWorkingDayCultureInfo); // friday + 2 working days on Default
//Default doesn't have supported holidays
Assert.IsTrue(thursday_plus_two_working_days_en == thursday.AddDays(4));
Assert.IsTrue(thursday_plus_two_working_days_en.DayOfWeek == DayOfWeek.Monday);
//Portuguese Holidays are supported
Assert.IsTrue(thursday_plus_two_working_days_pt == thursday.AddDays(6)); // + Good Friday (22-4-2011) + Carnation Revolution (25-4-2011)
Assert.IsTrue(thursday_plus_two_working_days_pt.DayOfWeek == DayOfWeek.Wednesday);
}
