private void ResolveOverflowingDateShould_ResolveResolveOverflowingDate_WhenDaysAndMonthsOverFlowYearAndMonth()
        {
            var initialDate = new SolarLunarNameSimple(1700, 13, 9);
            var nextDate    = new SolarLunarNameSimple(1701, 0, 9);

            TestTemplate(initialDate, nextDate);
        }
Beispiel #2
0
        private void NextMonthShould_ResolveNextMonth_WhenDaysAndMonthsNotOverFlowMonthOrYear()
        {
            var initialDate = new SolarLunarNameSimple(1700, 0, 1);
            var nextDate    = new SolarLunarNameSimple(1700, 0, 1);

            TestTemplate(initialDate, nextDate);
        }
        private void ResolveOverflowingDateShould_ResolveResolveOverflowingDate_WhenDaysOverFlowMonth()
        {
            var initialDate = new SolarLunarNameSimple(1700, 0, 20);
            var nextDate    = new SolarLunarNameSimple(1700, 1, 1);

            TestTemplate(initialDate, nextDate);
        }
Beispiel #4
0
        private void NextMonthShould_ResolveNextMonth_WhenMonthsOverFlowYear()
        {
            var initialDate = new SolarLunarNameSimple(1700, 13, 7);
            var nextDate    = new SolarLunarNameSimple(1701, 0, 7);

            TestTemplate(initialDate, nextDate);
        }
Beispiel #5
0
 public DateTime ConvertSolarLunarName(SolarLunarNameSimple solarLunarName)
 {
     try{
         return(ConvertSolarLunarNameExact(solarLunarName));
     }
     catch {
         var resolvedDate = ResolveOverflowingDate(solarLunarName);
         return(ConvertSolarLunarNameExact(resolvedDate));
     }
 }
        private void TestTemplate(SolarLunarNameSimple initialDate, SolarLunarNameSimple nextDate)
        {
            var nextSolarLunarDate = dp.ResolveOverflowingDate(initialDate);

            var result =
                nextSolarLunarDate.Year == nextDate.Year &&
                nextSolarLunarDate.LunarMonth == nextDate.LunarMonth &&
                nextSolarLunarDate.LunarDay == nextDate.LunarDay;

            Assert.True(result, "Should return expected data.");
        }
Beispiel #7
0
        public SolarLunarNameSimple ResolveOverflowingDate(SolarLunarNameSimple solarLunarNameSimple)
        {
            var reslovedMonth = ResolveOverflowingDateInner(solarLunarNameSimple);

            if (
                reslovedMonth.Year == solarLunarNameSimple.Year &&
                reslovedMonth.LunarMonth == solarLunarNameSimple.LunarMonth &&
                reslovedMonth.LunarDay == solarLunarNameSimple.LunarDay
                )
            {
                return(reslovedMonth);
            }
            else
            {
                return(ResolveOverflowingDateInner(reslovedMonth));
            }
        }
        public DateTime ConvertSolarLunarNameExact(SolarLunarNameSimple solarLunarName)
        {
            int daysInMonth = db.GetMonthData((ValidYear)solarLunarName.Year, (ValidLunarMonth)solarLunarName.LunarMonth).Days;

            if (daysInMonth < solarLunarName.LunarDay)
            {
                throw new DayDoesNotExistException(solarLunarName.Year, solarLunarName.LunarMonth, solarLunarName.LunarDay, daysInMonth);
            }
            ;

            var startOfYear = new DateTime(solarLunarName.Year, 1, 1);

            DateTime newMoon = db.GetYearData(solarLunarName.Year)
                               .OrderBy(x => x.FirstDay)
                               .Where((_, index) => index == solarLunarName.LunarMonth)
                               .Select(x => x.FirstDay)
                               .First();

            var solarDateTime = newMoon.AddDays(solarLunarName.LunarDay - 1);

            return(new DateTime(solarDateTime.Year, solarDateTime.Month, solarDateTime.Day));
        }
Beispiel #9
0
        private SolarLunarNameSimple ResolveOverflowingDateInner(SolarLunarNameSimple solarLunarNameSimple)
        {
            var data = db.GetYearData(solarLunarNameSimple.Year);

            var daysOfMonth =
                data
                .Where((_, index) => index == solarLunarNameSimple.LunarMonth)
                .Select(x => x.Days)
                .FirstOrDefault();

            int month = solarLunarNameSimple.LunarMonth;
            int daysRemaining;
            int dayDifference = solarLunarNameSimple.LunarDay - daysOfMonth;
            var year          = solarLunarNameSimple.Year;

            if (dayDifference > 0)
            {
                daysRemaining = dayDifference;
                if (daysOfMonth != 0)
                {
                    month += 1;
                }
            }
            else
            {
                daysRemaining = solarLunarNameSimple.LunarDay;
            }

            if (month > data.Count() - 1)
            {
                year += 1;
                month = month - data.Count();
            }

            return(new SolarLunarNameSimple(year, month, daysRemaining));
        }
        //TODO This is not really a test of ResolveOverflowingDate which does not throw exceptions of its own
        // This may be covered by tests on its dependency the calendar client
        private void ExceptionTemplate(int year, int lunarMonth, int lunarDay)
        {
            var solarLunarDate = new SolarLunarNameSimple(year, lunarMonth, lunarDay);

            Assert.Throws <YearOutOfRangeException>(() => dp.ResolveOverflowingDate(solarLunarDate));
        }
        public DateTime ConvertSolarLunarNameExact(int year, int month, int day)
        {
            var solarLunarName = new SolarLunarNameSimple(year, month, day);

            return(ConvertSolarLunarNameExact(solarLunarName));
        }
Beispiel #12
0
 public SolarLunarNameSimple NextMonth(SolarLunarNameSimple solarLunarNameSimple)
 {
     return(ResolveOverflowingDate(solarLunarNameSimple));
 }