Inheritance: YearTimeRange
        public void CollectExcludePeriodTest()
        {
            const int workingDays2011 = 365 - 2 - ( 51 * 2 ) - 1;
            const int workingDaysMarch2011 = 31 - 8; // total days - weekend days

            Year year2011 = new Year( 2011 );

            CalendarPeriodCollectorFilter filter1 = new CalendarPeriodCollectorFilter();
            filter1.AddWorkingWeekDays();
            CalendarPeriodCollector collector1 = new CalendarPeriodCollector( filter1, year2011 );
            collector1.CollectDays();
            Assert.AreEqual( collector1.Periods.Count, workingDays2011 );

            // exclude month
            CalendarPeriodCollectorFilter filter2 = new CalendarPeriodCollectorFilter();
            filter2.AddWorkingWeekDays();
            filter2.ExcludePeriods.Add( new Month( 2011, YearMonth.March ) );
            CalendarPeriodCollector collector2 = new CalendarPeriodCollector( filter2, year2011 );
            collector2.CollectDays();
            Assert.AreEqual( collector2.Periods.Count, workingDays2011 - workingDaysMarch2011 );

            // exclude weeks (holidays)
            CalendarPeriodCollectorFilter filter3 = new CalendarPeriodCollectorFilter();
            filter3.AddWorkingWeekDays();
            filter3.ExcludePeriods.Add( new Month( 2011, YearMonth.March ) );
            filter3.ExcludePeriods.Add( new Weeks( 2011, 26, 2 ) );
            CalendarPeriodCollector collector3 = new CalendarPeriodCollector( filter3, year2011 );
            collector3.CollectDays();
            Assert.AreEqual( collector3.Periods.Count, workingDays2011 - workingDaysMarch2011 - 10 );
        }
示例#2
0
 public void CurrentYearTest()
 {
     int currentYear = ClockProxy.Clock.Now.Year;
     Year year = new Year( currentYear );
     Assert.IsTrue( year.IsReadOnly );
     Assert.AreEqual( year.BaseYear, currentYear );
     Assert.AreEqual( year.Start, new DateTime( currentYear, 1, 1 ) );
     Assert.Less( year.End, new DateTime( currentYear + 1, 1, 1 ) );
 }
示例#3
0
        public void DefaultCalendarTest()
        {
            DateTime yearStart = new DateTime( ClockProxy.Clock.Now.Year, 1, 1 );

            Year year = new Year( yearStart );
            Assert.AreEqual( year.YearBaseMonth, YearMonth.January );
            Assert.AreEqual( year.BaseYear, yearStart.Year );
            Assert.AreEqual( year.Start, yearStart.Add( year.Calendar.StartOffset ) );
            Assert.AreEqual( year.End, yearStart.AddYears( 1 ).Add( year.Calendar.EndOffset ) );
        }
示例#4
0
        // ----------------------------------------------------------------------
        public static void ShowAll( int periodCount, int startYear, TimeCalendarConfig calendarConfig )
        {
            WriteLine( "Input: count={0}, year={1}", periodCount, startYear );
            WriteLine( "Calendar: base-month={0}, week-type={1}, culture={2}", calendarConfig.YearBaseMonth,  calendarConfig.YearWeekType, calendarConfig.Culture.Name );

            WriteLine();

            YearTimeRange yearTimeRange;
            if ( periodCount == 1 )
            {
                Year year = new Year( startYear, new TimeCalendar( calendarConfig ) );
                yearTimeRange = year;

                Year previousYear = year.GetPreviousYear();
                Year nextYears = year.GetNextYear();

                ShowYear( year );
                ShowCompactYear( previousYear, "Previous Year" );
                ShowCompactYear( nextYears, "Next Year" );
                WriteLine();
            }
            else
            {
                Years years = new Years( startYear, periodCount, new TimeCalendar( calendarConfig ) );
                yearTimeRange = years;

                ShowYears( years );
                WriteLine();

                foreach ( Year year in years.GetYears() )
                {
                    ShowCompactYear( year );
                }
                WriteLine();
            }

            foreach ( Halfyear halfyear in yearTimeRange.GetHalfyears() )
            {
                HalfyearDemo.ShowCompactHalfyear( halfyear );
            }
            WriteLine();
            foreach ( Quarter quarter in yearTimeRange.GetQuarters() )
            {
                QuarterDemo.ShowCompactQuarter( quarter );
            }
            WriteLine();
            foreach ( Month month in yearTimeRange.GetMonths() )
            {
                MonthDemo.ShowCompactMonth( month );
            }
            WriteLine();
        }
示例#5
0
        public void AddYearsTest()
        {
            Year currentYear = new Year( TimeCalendar.New( YearMonth.April ) );

            Assert.AreEqual( currentYear.AddYears( 0 ), currentYear );

            Year pastYear = currentYear.AddYears( -10 );
            Assert.AreEqual( pastYear.Start, currentYear.Start.AddYears( -10 ) );
            Assert.AreEqual( pastYear.End, currentYear.End.AddYears( -10 ) );

            Year futureYear = currentYear.AddYears( 10 );
            Assert.AreEqual( futureYear.Start, currentYear.Start.AddYears( 10 ) );
            Assert.AreEqual( futureYear.End, currentYear.End.AddYears( 10 ) );
        }
示例#6
0
        public void GetHalfyearsTest()
        {
            Year year = new Year( TimeCalendar.New( YearMonth.October ) );

            ITimePeriodCollection halfyears = year.GetHalfyears();
            Assert.AreNotEqual( halfyears, null );

            int index = 0;
            foreach ( Halfyear halfyear in halfyears )
            {
                Assert.AreEqual( halfyear.BaseYear, year.BaseYear );
                Assert.AreEqual( halfyear.Start, year.Start.AddMonths( index * TimeSpec.MonthsPerHalfyear ) );
                Assert.AreEqual( halfyear.End, halfyear.Calendar.MapEnd( halfyear.Start.AddMonths( TimeSpec.MonthsPerHalfyear ) ) );
                index++;
            }
            Assert.AreEqual( index, TimeSpec.HalfyearsPerYear );
        }
示例#7
0
        public void CalendarQuarterOfYearTest()
        {
            int currentYear = ClockProxy.Clock.Now.Year;

            TimeCalendar timeCalendar = TimeCalendar.New( YearMonth.October );
            Year calendarYear = new Year( currentYear, timeCalendar );
            Assert.AreEqual( calendarYear.YearBaseMonth, YearMonth.October );
            Assert.AreEqual( calendarYear.BaseYear, currentYear );
            Assert.AreEqual( calendarYear.Start, new DateTime( currentYear, 10, 1 ) );
            Assert.AreEqual( calendarYear.End, calendarYear.Calendar.MapEnd( calendarYear.Start.AddYears( 1 ) ) );

            // Q1
            Quarter q1 = new Quarter( calendarYear.BaseYear, YearQuarter.First, timeCalendar );
            Assert.AreEqual( q1.YearBaseMonth, calendarYear.YearBaseMonth );
            Assert.AreEqual( q1.BaseYear, calendarYear.BaseYear );
            Assert.AreEqual( q1.Start, new DateTime( currentYear, 10, 1 ) );
            Assert.AreEqual( q1.End, q1.Calendar.MapEnd( q1.Start.AddMonths( 3 ) ) );

            // Q2
            Quarter q2 = new Quarter( calendarYear.BaseYear, YearQuarter.Second, timeCalendar );
            Assert.AreEqual( q2.YearBaseMonth, calendarYear.YearBaseMonth );
            Assert.AreEqual( q2.BaseYear, calendarYear.BaseYear );
            Assert.AreEqual( q2.Start, new DateTime( currentYear + 1, 1, 1 ) );
            Assert.AreEqual( q2.End, q2.Calendar.MapEnd( q2.Start.AddMonths( 3 ) ) );

            // Q3
            Quarter q3 = new Quarter( calendarYear.BaseYear, YearQuarter.Third, timeCalendar );
            Assert.AreEqual( q3.YearBaseMonth, calendarYear.YearBaseMonth );
            Assert.AreEqual( q3.BaseYear, calendarYear.BaseYear );
            Assert.AreEqual( q3.Start, new DateTime( currentYear + 1, 4, 1 ) );
            Assert.AreEqual( q3.End, q3.Calendar.MapEnd( q3.Start.AddMonths( 3 ) ) );

            // Q4
            Quarter q4 = new Quarter( calendarYear.BaseYear, YearQuarter.Fourth, timeCalendar );
            Assert.AreEqual( q4.YearBaseMonth, calendarYear.YearBaseMonth );
            Assert.AreEqual( q4.BaseYear, calendarYear.BaseYear );
            Assert.AreEqual( q4.Start, new DateTime( currentYear + 1, 7, 1 ) );
            Assert.AreEqual( q4.End, q4.Calendar.MapEnd( q4.Start.AddMonths( 3 ) ) );
        }
示例#8
0
        public void GetPreviousYearTest()
        {
            DateTime currentYearStart = new DateTime( ClockProxy.Clock.Now.Year, 4, 1 );

            Year currentYear = new Year( currentYearStart.Year, TimeCalendar.New( TimeSpan.Zero, TimeSpan.Zero, YearMonth.April ) );

            Year previousYear = currentYear.GetPreviousYear();
            Assert.IsTrue( previousYear.IsReadOnly );
            Assert.AreEqual( previousYear.YearBaseMonth, YearMonth.April );
            Assert.AreEqual( previousYear.BaseYear, currentYearStart.Year - 1 );
            Assert.AreEqual( previousYear.Start, currentYearStart.AddYears( -1 ) );
            Assert.AreEqual( previousYear.End, currentYearStart );
        }
        } // EnterYears

        // ----------------------------------------------------------------------
        protected virtual bool EnterMonths(Year year, TContext context)
        {
            return(true);
        } // EnterMonths
示例#10
0
        public void YearPeriodTest()
        {
            int currentYear = ClockProxy.Clock.Now.Year;
            DateTime yearStart = new DateTime( currentYear, 4, 1 );
            DateTime yearEnd = yearStart.AddYears( 1 );

            Year year = new Year( currentYear, TimeCalendar.New( TimeSpan.Zero, TimeSpan.Zero, YearMonth.April ) );
            Assert.IsTrue( year.IsReadOnly );
            Assert.AreEqual( year.YearBaseMonth, YearMonth.April );
            Assert.AreEqual( year.BaseYear, yearStart.Year );
            Assert.AreEqual( year.Start, yearStart );
            Assert.AreEqual( year.End, yearEnd );
        }
示例#11
0
 public void YearMomentTest()
 {
     const int yearIndex = 2002;
     Year year = new Year( new DateTime( yearIndex, 3, 15 ) );
     Assert.IsTrue( year.IsReadOnly );
     Assert.AreEqual( year.BaseYear, yearIndex );
     Assert.AreEqual( year.Start, new DateTime( yearIndex, 1, 1 ) );
     Assert.Less( year.End, new DateTime( yearIndex + 1, 1, 1 ) );
 }
示例#12
0
        public void FiscalYearWeekCountSample()
        {
            TimeCalendar calendar = new TimeCalendar(
                new TimeCalendarConfig
                {
                    YearBaseMonth = YearMonth.April,  //  April year base month
                    //YearWeekType = YearWeekType.Iso8601, // ISO 8601 week numbering
                    YearType = YearType.FiscalYear// treat years as fiscal years
                } );

            bool countOnlyFullWeeks = true;
            Year year = new Year( 2012, calendar );
            foreach ( Month month in year.GetMonths() )
            {
                Month nextMonth = month.GetNextMonth();
                Week week = new Week( month.Start.Date );
                int weekCount = 0;
                while ( week.Start.Date < nextMonth.Start.Date )
                {
                    if ( countOnlyFullWeeks )
                    {
                        if ( month.HasInside( week ) )
                        {
                            weekCount++;
                        }
                    }
                    else
                    {
                        weekCount++;
                    }
                    week = week.GetNextWeek();
                }
                Console.WriteLine( "Month: " + month + ", Tot Weeks : " + weekCount );
            }
        }
示例#13
0
 // ----------------------------------------------------------------------
 public static void ShowYear( Year year, string caption = "Year" )
 {
     WriteLine( "{0}: {1}", caption, year );
     WriteIndentLine( "YearBaseMonth: {0}", year.YearBaseMonth );
     WriteIndentLine( "IsCalendarYear: {0}", year.IsCalendarYear );
     WriteIndentLine( "StartYear: {0}", year.StartYear );
     WriteIndentLine( "FirstDayStart: {0}", Format( year.FirstDayStart ) );
     WriteIndentLine( "LastDayStart: {0}", Format( year.LastDayStart ) );
     WriteIndentLine( "LastMonthStart: {0}", Format( year.LastMonthStart ) );
     WriteIndentLine( "YearName: {0}", year.YearName );
     WriteLine();
 }
示例#14
0
 // ----------------------------------------------------------------------
 private void UpdateSelectedPeriodInfo()
 {
     TimeCalendar timeCalendar = TimeCalendar.New( SelectedYearBaseMonth );
     switch ( SelectedPeriodMode )
     {
         case TimePeriodMode.Year:
             Year year = new Year( WorkingDate, timeCalendar );
             periodInfo.Clear();
             periodInfo.AddItem( "Year", year );
             periodInfo.AddItem( "YearBaseMonth", year.YearBaseMonth );
             periodInfo.AddItem( "IsCalendarYear", year.IsCalendarYear );
             periodInfo.AddItem( "StartYear", year.StartYear );
             periodInfo.AddItem( "FirstDayStart", year.FirstDayStart );
             periodInfo.AddItem( "LastDayStart", year.LastDayStart );
             periodInfo.AddItem( "LastMonthStart", year.LastMonthStart );
             periodInfo.AddItem( "YearName", year.YearName );
             periodInfo.AddSection( "Previous/Next" );
             periodInfo.AddItem( "Previous", year.GetPreviousYear() );
             periodInfo.AddItem( "Next", year.GetNextYear() );
             periodInfo.AddSubitems( "Halfyears", year.GetHalfyears() );
             periodInfo.AddSubitems( "Quarters", year.GetQuarters() );
             periodInfo.AddSubitems( "Months", year.GetMonths() );
             SelectedPeriodInfo = periodInfo.ToString();
             break;
         case TimePeriodMode.Halfyear:
             Halfyear halfyear = new Halfyear( WorkingDate, timeCalendar );
             periodInfo.Clear();
             periodInfo.AddItem( "Halfyear", halfyear );
             periodInfo.AddItem( "YearBaseMonth", halfyear.YearBaseMonth );
             periodInfo.AddItem( "StartMonth", halfyear.StartMonth );
             periodInfo.AddItem( "Year", halfyear.Year );
             periodInfo.AddItem( "YearHalfyear", halfyear.YearHalfyear );
             periodInfo.AddItem( "IsCalendarHalfyear", halfyear.IsCalendarHalfyear );
             periodInfo.AddItem( "MultipleCalendarYears", halfyear.MultipleCalendarYears );
             periodInfo.AddItem( "HalfyearName", halfyear.HalfyearName );
             periodInfo.AddItem( "HalfyearOfYearName", halfyear.HalfyearOfYearName );
             periodInfo.AddItem( "LastDayStart", halfyear.LastDayStart );
             periodInfo.AddItem( "LastMonthStart", halfyear.LastMonthStart );
             periodInfo.AddSection( "Previous/Next" );
             periodInfo.AddItem( "Previousr", halfyear.GetPreviousHalfyear() );
             periodInfo.AddItem( "Next", halfyear.GetNextHalfyear() );
             periodInfo.AddSubitems( "Quarters", halfyear.GetQuarters() );
             periodInfo.AddSubitems( "Months", halfyear.GetMonths() );
             SelectedPeriodInfo = periodInfo.ToString();
             break;
         case TimePeriodMode.Quarter:
             Quarter quarter = new Quarter( WorkingDate, timeCalendar );
             periodInfo.Clear();
             periodInfo.AddItem( "Quarter", quarter );
             periodInfo.AddItem( "YearBaseMonth", quarter.YearBaseMonth );
             periodInfo.AddItem( "StartMonth", quarter.StartMonth );
             periodInfo.AddItem( "Year", quarter.Year );
             periodInfo.AddItem( "YearQuarter", quarter.YearQuarter );
             periodInfo.AddItem( "IsCalendarQuarter", quarter.IsCalendarQuarter );
             periodInfo.AddItem( "MultipleCalendarYears", quarter.MultipleCalendarYears );
             periodInfo.AddItem( "QuarterName", quarter.QuarterName );
             periodInfo.AddItem( "QuarterOfYearName", quarter.QuarterOfYearName );
             periodInfo.AddItem( "LastDayStart", quarter.FirstDayStart );
             periodInfo.AddItem( "LastMonthStart", quarter.LastDayStart );
             periodInfo.AddSection( "Previous/Next" );
             periodInfo.AddItem( "Previous", quarter.GetPreviousQuarter() );
             periodInfo.AddItem( "Next", quarter.GetNextQuarter() );
             periodInfo.AddSubitems( "Months", quarter.GetMonths() );
             SelectedPeriodInfo = periodInfo.ToString();
             break;
         case TimePeriodMode.Month:
             Month month = new Month( WorkingDate, timeCalendar );
             periodInfo.Clear();
             periodInfo.AddItem( "Month", month );
             periodInfo.AddItem( "YearBaseMonth", month.YearMonth );
             periodInfo.AddItem( "Year", month.Year );
             periodInfo.AddItem( "DaysInMonth", month.DaysInMonth );
             periodInfo.AddItem( "MonthName", month.MonthName );
             periodInfo.AddItem( "MonthOfYearName", month.MonthOfYearName );
             periodInfo.AddItem( "LastDayStart", month.FirstDayStart );
             periodInfo.AddItem( "LastMonthStart", month.LastDayStart );
             periodInfo.AddSection( "Previous/Next" );
             periodInfo.AddItem( "Previous", month.GetPreviousMonth() );
             periodInfo.AddItem( "Next", month.GetNextMonth() );
             periodInfo.AddSubitems( "Days", month.GetDays() );
             SelectedPeriodInfo = periodInfo.ToString();
             break;
         case TimePeriodMode.Week:
             Week week = new Week( WorkingDate, timeCalendar );
             periodInfo.Clear();
             periodInfo.AddItem( "Week", week );
             periodInfo.AddItem( "MultipleCalendarYears", week.MultipleCalendarYears );
             periodInfo.AddItem( "FirstDayStart", week.FirstDayStart );
             periodInfo.AddItem( "FirstDayOfWeek", week.FirstDayOfWeek );
             periodInfo.AddItem( "LastDayStart", week.LastDayStart );
             periodInfo.AddItem( "LastDayOfWeek", week.LastDayOfWeek );
             periodInfo.AddItem( "WeekOfYear", week.WeekOfYear );
             periodInfo.AddItem( "WeekOfYearName", week.WeekOfYearName );
             periodInfo.AddSection( "Previous/Next" );
             periodInfo.AddItem( "Previous", week.GetPreviousWeek() );
             periodInfo.AddItem( "Next", week.GetNextWeek() );
             periodInfo.AddSubitems( "Days", week.GetDays() );
             SelectedPeriodInfo = periodInfo.ToString();
             break;
         case TimePeriodMode.Day:
             Day day = new Day( WorkingDate, timeCalendar );
             periodInfo.Clear();
             periodInfo.AddItem( "Day", day );
             periodInfo.AddItem( "Year", day.Year );
             periodInfo.AddItem( "FirstDayStart", day.FirstDayStart );
             periodInfo.AddItem( "Month", day.Month );
             periodInfo.AddItem( "DayValue", day.DayValue );
             periodInfo.AddItem( "DayOfWeek", day.DayOfWeek );
             periodInfo.AddItem( "DayName", day.DayName );
             periodInfo.AddItem( "FirstHourStart", day.FirstHourStart );
             periodInfo.AddItem( "LastHourStart", day.LastHourStart );
             periodInfo.AddSection( "Previous/Next" );
             periodInfo.AddItem( "Previous", day.GetPreviousDay() );
             periodInfo.AddItem( "Next", day.GetNextDay() );
             periodInfo.AddSubitems( "Hours", day.GetHours() );
             SelectedPeriodInfo = periodInfo.ToString();
             break;
         case TimePeriodMode.Hour:
             Hour hour = new Hour( WorkingDate, timeCalendar );
             periodInfo.Clear();
             periodInfo.AddItem( "Hour", hour );
             periodInfo.AddItem( "Year", hour.Year );
             periodInfo.AddItem( "Month", hour.Month );
             periodInfo.AddItem( "Day", hour.Day );
             periodInfo.AddItem( "HourValue", hour.HourValue );
             periodInfo.AddItem( "FirstMinuteStart", hour.FirstMinuteStart );
             periodInfo.AddItem( "LastMinuteStart", hour.LastMinuteStart );
             periodInfo.AddSection( "Previous/Next" );
             periodInfo.AddItem( "Previous", hour.GetPreviousHour() );
             periodInfo.AddItem( "Next", hour.GetNextHour() );
             periodInfo.AddSubitems( "Minutes", hour.GetMinutes() );
             SelectedPeriodInfo = periodInfo.ToString();
             break;
         case TimePeriodMode.Minute:
             Minute minute = new Minute( WorkingDate, timeCalendar );
             periodInfo.Clear();
             periodInfo.AddItem( "Minute", minute );
             periodInfo.AddItem( "Year", minute.Year );
             periodInfo.AddItem( "Month", minute.Month );
             periodInfo.AddItem( "Day", minute.Day );
             periodInfo.AddItem( "Hour", minute.Hour );
             periodInfo.AddItem( "MinuteValue", minute.MinuteValue );
             periodInfo.AddSection( "Previous/Next" );
             periodInfo.AddItem( "Previous", minute.GetPreviousMinute() );
             periodInfo.AddItem( "Next", minute.GetNextMinute() );
             SelectedPeriodInfo = periodInfo.ToString();
             break;
     }
 }
        }         // EnterYears

        // ----------------------------------------------------------------------
        protected override bool EnterMonths(Year year, CalendarPeriodCollectorContext context)
        {
            return
                (context.Scope == CalendarPeriodCollectorContext.CollectType.Day ||
                 context.Scope == CalendarPeriodCollectorContext.CollectType.Hour);
        }         // EnterMonths
示例#16
0
 public void YearQuartersSample()
 {
     Year year = new Year( 2012 );
     ITimePeriodCollection quarters = year.GetQuarters();
     Console.WriteLine( "Quarters of Year: {0}", year );
     // > Quarters of Year: 2012; 01.01.2012 - 31.12.2012 | 365.23:59
     foreach ( Quarter quarter in quarters )
     {
         Console.WriteLine( "Quarter: {0}", quarter );
     }
     // > Quarter: Q1 2012; 01.01.2012 - 31.03.2012 | 90.23:59
     // > Quarter: Q2 2012; 01.04.2012 - 30.06.2012 | 90.23:59
     // > Quarter: Q3 2012; 01.07.2012 - 30.09.2012 | 91.23:59
     // > Quarter: Q4 2012; 01.10.2012 - 31.12.2012 | 91.23:59
 }
示例#17
0
        public void FiscalYearTest()
        {
            DateTime testDate = new DateTime( 2008, 11, 18 );
            Year year = new Year( testDate, TimeCalendar.New( YearMonth.October ) );

            Assert.AreEqual( year.YearBaseMonth, YearMonth.October );
            Assert.AreEqual( year.BaseYear, 2008 );

            // start & end
            Assert.AreEqual( year.Start.Year, testDate.Year );
            Assert.AreEqual( year.Start.Month, 10 );
            Assert.AreEqual( year.Start.Day, 1 );
            Assert.AreEqual( year.End.Year, testDate.Year + 1 );
            Assert.AreEqual( year.End.Month, 9 );
            Assert.AreEqual( year.End.Day, 30 );

            // half years
            ITimePeriodCollection halfyears = year.GetHalfyears();
            foreach ( Halfyear halfyear in halfyears )
            {
                switch ( halfyear.YearHalfyear )
                {
                    case YearHalfyear.First:
                        Assert.AreEqual( halfyear.Start, year.Start );
                        Assert.AreEqual( halfyear.Start.Year, testDate.Year );
                        Assert.AreEqual( halfyear.Start.Month, 10 );
                        Assert.AreEqual( halfyear.Start.Day, 1 );
                        Assert.AreEqual( halfyear.End.Year, testDate.Year + 1 );
                        Assert.AreEqual( halfyear.End.Month, 3 );
                        Assert.AreEqual( halfyear.End.Day, 31 );
                        break;
                    case YearHalfyear.Second:
                        Assert.AreEqual( halfyear.End, year.End );
                        Assert.AreEqual( halfyear.Start.Year, testDate.Year + 1 );
                        Assert.AreEqual( halfyear.Start.Month, 4 );
                        Assert.AreEqual( halfyear.Start.Day, 1 );
                        Assert.AreEqual( halfyear.End.Year, testDate.Year + 1 );
                        Assert.AreEqual( halfyear.End.Month, 9 );
                        Assert.AreEqual( halfyear.End.Day, 30 );
                        break;
                }
            }

            // half years
            ITimePeriodCollection quarters = year.GetQuarters();
            foreach ( Quarter quarter in quarters )
            {
                switch ( quarter.YearQuarter )
                {
                    case YearQuarter.First:
                        Assert.AreEqual( quarter.Start, year.Start );
                        Assert.AreEqual( quarter.Start.Year, testDate.Year );
                        Assert.AreEqual( quarter.Start.Month, 10 );
                        Assert.AreEqual( quarter.Start.Day, 1 );
                        Assert.AreEqual( quarter.End.Year, testDate.Year );
                        Assert.AreEqual( quarter.End.Month, 12 );
                        Assert.AreEqual( quarter.End.Day, 31 );
                        break;
                    case YearQuarter.Second:
                        Assert.AreEqual( quarter.Start.Year, testDate.Year + 1 );
                        Assert.AreEqual( quarter.Start.Month, 1 );
                        Assert.AreEqual( quarter.Start.Day, 1 );
                        Assert.AreEqual( quarter.End.Year, testDate.Year + 1 );
                        Assert.AreEqual( quarter.End.Month, 3 );
                        Assert.AreEqual( quarter.End.Day, 31 );
                        break;
                    case YearQuarter.Third:
                        Assert.AreEqual( quarter.Start.Year, testDate.Year + 1 );
                        Assert.AreEqual( quarter.Start.Month, 4 );
                        Assert.AreEqual( quarter.Start.Day, 1 );
                        Assert.AreEqual( quarter.End.Year, testDate.Year + 1 );
                        Assert.AreEqual( quarter.End.Month, 6 );
                        Assert.AreEqual( quarter.End.Day, 30 );
                        break;
                    case YearQuarter.Fourth:
                        Assert.AreEqual( quarter.End, year.End );
                        Assert.AreEqual( quarter.Start.Year, testDate.Year + 1 );
                        Assert.AreEqual( quarter.Start.Month, 7 );
                        Assert.AreEqual( quarter.Start.Day, 1 );
                        Assert.AreEqual( quarter.End.Year, testDate.Year + 1 );
                        Assert.AreEqual( quarter.End.Month, 9 );
                        Assert.AreEqual( quarter.End.Day, 30 );
                        break;
                }
            }

            // months
            ITimePeriodCollection months = year.GetMonths();
            int monthIndex = 0;
            foreach ( Month month in months )
            {
                switch ( monthIndex )
                {
                    case 0:
                        Assert.AreEqual( month.Start, year.Start );
                        break;
                    case TimeSpec.MonthsPerYear - 1:
                        Assert.AreEqual( month.End, year.End );
                        break;
                }

                DateTime startDate = new DateTime( year.BaseYear, year.Start.Month, 1 ).AddMonths( monthIndex );
                Assert.AreEqual( month.Start.Year, startDate.Year );
                Assert.AreEqual( month.Start.Month, startDate.Month );
                Assert.AreEqual( month.Start.Day, startDate.Day );
                Assert.AreEqual( month.End.Year, startDate.Year );
                Assert.AreEqual( month.End.Month, startDate.Month );

                monthIndex++;
            }
        }
        } // OnVisitYears

        // ----------------------------------------------------------------------
        protected virtual bool OnVisitYear(Year year, TContext context)
        {
            return(true);
        } // OnVisitYear
示例#19
0
        public void GetMonthsTest()
        {
            Year year = new Year( TimeCalendar.New( YearMonth.October ) );

            ITimePeriodCollection months = year.GetMonths();
            Assert.AreNotEqual( months, null );

            int index = 0;
            foreach ( Month month in months )
            {
                Assert.AreEqual( month.Start, year.Start.AddMonths( index ) );
                Assert.AreEqual( month.End, month.Calendar.MapEnd( month.Start.AddMonths( 1 ) ) );
                index++;
            }
            Assert.AreEqual( index, TimeSpec.MonthsPerYear );
        }
示例#20
0
        public void InitValuesTest()
        {
            DateTime now = ClockProxy.Clock.Now;
            DateTime thisYear = new DateTime( now.Year, 1, 1 );
            DateTime nextYear = thisYear.AddYears( 1 );
            Year year = new Year( now, TimeCalendar.NewEmptyOffset() );

            Assert.AreEqual( year.Start.Year, thisYear.Year );
            Assert.AreEqual( year.Start.Month, thisYear.Month );
            Assert.AreEqual( year.Start.Day, thisYear.Day );
            Assert.AreEqual( year.Start.Hour, 0 );
            Assert.AreEqual( year.Start.Minute, 0 );
            Assert.AreEqual( year.Start.Second, 0 );
            Assert.AreEqual( year.Start.Millisecond, 0 );

            Assert.AreEqual( year.End.Year, nextYear.Year );
            Assert.AreEqual( year.End.Month, nextYear.Month );
            Assert.AreEqual( year.End.Day, nextYear.Day );
            Assert.AreEqual( year.End.Hour, 0 );
            Assert.AreEqual( year.End.Minute, 0 );
            Assert.AreEqual( year.End.Second, 0 );
            Assert.AreEqual( year.End.Millisecond, 0 );
        }
示例#21
0
 // ----------------------------------------------------------------------
 public static void ShowCompactYear( Year year, string caption = "Year" )
 {
     WriteLine( "{0}: {1}", caption, year );
 }
示例#22
0
 public void YearBaseMonthTest()
 {
     Year year = new Year( TimeCalendar.New( YearMonth.April ) );
     Assert.AreEqual( year.YearBaseMonth, YearMonth.April );
     Assert.AreEqual( new Year().YearBaseMonth, YearMonth.January );
 }
示例#23
0
        public void YearCompareTest()
        {
            DateTime moment = new DateTime( 2008, 2, 18 );
            Year calendarYearSweden = new Year( moment, TimeCalendar.New( YearMonth.January ) );
            Assert.AreEqual( calendarYearSweden.YearBaseMonth, YearMonth.January );

            Year calendarYearGermany = new Year( moment, TimeCalendar.New( YearMonth.April ) );
            Assert.AreEqual( calendarYearGermany.YearBaseMonth, YearMonth.April );

            Year calendarYearUnitedStates = new Year( moment, TimeCalendar.New( YearMonth.October ) );
            Assert.AreEqual( calendarYearUnitedStates.YearBaseMonth, YearMonth.October );

            Assert.AreNotEqual( calendarYearSweden, calendarYearGermany );
            Assert.AreNotEqual( calendarYearSweden, calendarYearUnitedStates );
            Assert.AreNotEqual( calendarYearGermany, calendarYearUnitedStates );

            Assert.AreEqual( calendarYearSweden.BaseYear, calendarYearGermany.BaseYear + 1 );
            Assert.AreEqual( calendarYearSweden.BaseYear, calendarYearUnitedStates.BaseYear + 1 );

            Assert.AreEqual( calendarYearSweden.GetPreviousYear().BaseYear, calendarYearGermany.GetPreviousYear().BaseYear + 1 );
            Assert.AreEqual( calendarYearSweden.GetPreviousYear().BaseYear, calendarYearUnitedStates.GetPreviousYear().BaseYear + 1 );

            Assert.AreEqual( calendarYearSweden.GetNextYear().BaseYear, calendarYearGermany.GetNextYear().BaseYear + 1 );
            Assert.AreEqual( calendarYearSweden.GetNextYear().BaseYear, calendarYearUnitedStates.GetNextYear().BaseYear + 1 );

            Assert.IsTrue( calendarYearSweden.IntersectsWith( calendarYearGermany ) );
            Assert.IsTrue( calendarYearSweden.IntersectsWith( calendarYearUnitedStates ) );
            Assert.IsTrue( calendarYearGermany.IntersectsWith( calendarYearUnitedStates ) );
        }
示例#24
0
        // ----------------------------------------------------------------------
        private void SelectPeriod( PeriodSelectType periodSelectType )
        {
            int offset = 0;
            switch ( periodSelectType )
            {
                case PeriodSelectType.Previous:
                    offset = -1;
                    break;
                case PeriodSelectType.Current:
                    ResetWorkingPeriod();
                    return;
                case PeriodSelectType.Next:
                    offset = 1;
                    break;
            }

            switch ( WorkingTimePeriod )
            {
                case TimePeriodMode.Year:
                    Year year = new Year( WorkingPeriodStartDate );
                    SetWorkingPeriod( year.AddYears( offset ) );
                    break;
                case TimePeriodMode.Halfyear:
                    Halfyear halfyear = new Halfyear( WorkingPeriodStartDate );
                    SetWorkingPeriod( halfyear.AddHalfyears( offset ) );
                    break;
                case TimePeriodMode.Quarter:
                    Quarter quarter = new Quarter( WorkingPeriodStartDate );
                    SetWorkingPeriod( quarter.AddQuarters( offset ) );
                    break;
                case TimePeriodMode.Month:
                    Month month = new Month( WorkingPeriodStartDate );
                    SetWorkingPeriod( month.AddMonths( offset ) );
                    break;
                case TimePeriodMode.Week:
                    Week week = new Week( WorkingPeriodStartDate );
                    SetWorkingPeriod( week.AddWeeks( offset ) );
                    break;
                case TimePeriodMode.Day:
                    Day day = new Day( WorkingPeriodStartDate );
                    SetWorkingPeriod( day.AddDays( offset ) );
                    break;
            }
        }