public void NegTest1()
        {
            System.Globalization.Calendar tc = new TaiwanCalendar();
            Random rand        = new Random(-55);
            int    year        = rand.Next(tc.MaxSupportedDateTime.Year - 1910, Int32.MaxValue);
            int    month       = rand.Next(1, 13);
            int    day         = rand.Next(1, 29);
            int    hour        = rand.Next(0, 24);
            int    minute      = rand.Next(0, 60);
            int    second      = rand.Next(0, 60);
            int    milliSecond = rand.Next(0, 1000);
            int    era         = tc.Eras[0];

            Assert.Throws <ArgumentOutOfRangeException>(() =>
            {
                tc.ToDateTime(year, month, day, hour, minute, second, milliSecond, era);
            });

            year = rand.Next(Int32.MinValue, tc.MinSupportedDateTime.Year);

            era = tc.Eras[0];
            Assert.Throws <ArgumentOutOfRangeException>(() =>
            {
                tc.ToDateTime(year, month, day, hour, minute, second, milliSecond, era);
            });
        }
 public void ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond)
 {
     TaiwanCalendar calendar = new TaiwanCalendar();
     DateTime expected = new DateTime(year + 1911, month, day, hour, minute, second, millisecond);
     Assert.Equal(expected, calendar.ToDateTime(year, month, day, hour, minute, second, millisecond));
     Assert.Equal(expected, calendar.ToDateTime(year, month, day, hour, minute, second, millisecond, 0));
     Assert.Equal(expected, calendar.ToDateTime(year, month, day, hour, minute, second, millisecond, 1));
 }
Exemple #3
0
        public void ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond)
        {
            TaiwanCalendar calendar = new TaiwanCalendar();
            DateTime       expected = new DateTime(year + 1911, month, day, hour, minute, second, millisecond);

            Assert.Equal(expected, calendar.ToDateTime(year, month, day, hour, minute, second, millisecond));
            Assert.Equal(expected, calendar.ToDateTime(year, month, day, hour, minute, second, millisecond, 0));
            Assert.Equal(expected, calendar.ToDateTime(year, month, day, hour, minute, second, millisecond, 1));
        }
        public void NegTest2()
        {
            System.Globalization.Calendar tc = new TaiwanCalendar();
            Random rand  = new Random(-55);
            int    year  = rand.Next(tc.MinSupportedDateTime.Year, tc.MaxSupportedDateTime.Year - 1911);
            int    month = rand.Next(1, 12);
            int    day;

            if (tc.IsLeapYear(year))
            {
                day = rand.Next(1, 30);
            }
            else
            {
                day = rand.Next(1, 29);
            }

            DateTime dt       = tc.ToDateTime(year, month, day, 0, 0, 0, 0);
            int      addValue = rand.Next(Int32.MinValue, (tc.MinSupportedDateTime.Year - year) * 12);

            Assert.Throws <ArgumentOutOfRangeException>(() =>
            {
                tc.AddMonths(dt, addValue);
            });
        }
        public void PosTest3()
        {
            System.Globalization.Calendar tc = new TaiwanCalendar();
            DateTime minDT       = tc.MinSupportedDateTime;
            int      year        = 1;
            int      month       = 1;
            int      day         = 1;
            int      hour        = 0;
            int      minute      = 0;
            int      second      = 0;
            int      milliSecond = 0;
            int      era;

            for (int i = 0; i < tc.Eras.Length; i++)
            {
                era = tc.Eras[i];
                DateTime dt = tc.ToDateTime(year, month, day, hour, minute, second, milliSecond);
                Assert.Equal(minDT, dt);
            }
        }
        public void PosTest2()
        {
            System.Globalization.Calendar tc = new TaiwanCalendar();
            int year        = 8088;
            int month       = 12;
            int day         = 31;
            int hour        = 23;
            int minute      = 59;
            int second      = 59;
            int milliSecond = 999;
            int era;

            for (int i = 0; i < tc.Eras.Length; i++)
            {
                era = tc.Eras[i];
                DateTime dt       = tc.ToDateTime(year, month, day, hour, minute, second, milliSecond);
                DateTime desireDT = new DateTime(year + 1911, month, day, hour, minute, second, milliSecond);
                Assert.Equal(desireDT, dt);
            }
        }
        public void PosTest1()
        {
            System.Globalization.Calendar tc = new TaiwanCalendar();
            Random rand        = new Random(-55);
            int    year        = rand.Next(tc.MinSupportedDateTime.Year, tc.MaxSupportedDateTime.Year - 1911);
            int    month       = rand.Next(1, 13);
            int    day         = rand.Next(1, 29);
            int    hour        = rand.Next(0, 24);
            int    minute      = rand.Next(0, 60);
            int    second      = rand.Next(0, 60);
            int    milliSecond = rand.Next(0, 1000);
            int    era         = 0;

            for (int i = 0; i < tc.Eras.Length; i++)
            {
                era = tc.Eras[i];
                DateTime dt        = tc.ToDateTime(year, month, day, hour, minute, second, milliSecond);
                DateTime desiredDT = new DateTime(year + 1911, month, day, hour, minute, second, milliSecond);
                Assert.Equal(desiredDT, dt);
            }
        }
        public void PosTest5()
        {
            System.Globalization.Calendar tc = new TaiwanCalendar();
            Random rand  = new Random(-55);
            int    year  = rand.Next(tc.MinSupportedDateTime.Year, tc.MaxSupportedDateTime.Year - 1911);
            int    month = rand.Next(1, 12);
            int    day;

            if (tc.IsLeapYear(year))
            {
                day = rand.Next(1, _DAYS_PER_MONTHS_IN_LEAP_YEAR[month] + 1);
            }
            else
            {
                day = rand.Next(1, _DAYS_PER_MONTHS_IN_NO_LEAP_YEAR[month] + 1);
            }

            DateTime dt = tc.ToDateTime(year, month, day, 0, 0, 0, 0);
            int      i  = 0;

            VerificationHelper(dt, i);
        }
        public void PosTest1()
        {
            System.Globalization.Calendar tc = new TaiwanCalendar();
            Random rand  = new Random(-55);
            int    year  = rand.Next(tc.MinSupportedDateTime.Year, tc.MaxSupportedDateTime.Year - 1911);
            int    month = rand.Next(1, 12);
            int    day;

            if (tc.IsLeapYear(year))
            {
                day = rand.Next(1, 30);
            }
            else
            {
                day = rand.Next(1, 29);
            }

            DateTime dt         = tc.ToDateTime(year, month, day, 0, 0, 0, 0);
            int      actualDays = dt.Day;

            Assert.Equal(tc.GetDayOfMonth(dt), actualDays);
        }
        public void PosTest1()
        {
            System.Globalization.Calendar tc = new TaiwanCalendar();
            Random rand  = new Random(-55);
            int    year  = rand.Next(tc.MinSupportedDateTime.Year, tc.MaxSupportedDateTime.Year - 1911);
            int    month = rand.Next(1, 12);
            int    day;

            if (tc.IsLeapYear(year))
            {
                day = rand.Next(1, _DAYS_PER_MONTHS_IN_LEAP_YEAR[month] + 1);
            }
            else
            {
                day = rand.Next(1, _DAYS_PER_MONTHS_IN_NO_LEAP_YEAR[month] + 1);
            }

            DateTime dt          = tc.ToDateTime(year, month, day, 0, 0, 0, 0);
            int      actualMonth = dt.Month;

            Assert.Equal(tc.GetMonth(dt), actualMonth);
        }