public void DateExceptions()
{
Assert.ThrowsException <ArgumentOutOfRangeException>(() => { Date d = new Date(0, 1, 1); });
Assert.ThrowsException <ArgumentOutOfRangeException>(() => { Date d = new Date(2000, -1, 1); });
Assert.ThrowsException <ArgumentOutOfRangeException>(() => { Date d = new Date(2000, 1, 32); });
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Date.IsLeapYear(-1));
Assert.ThrowsException <ArgumentNullException>(() => new Date(2000, 1, 15).ToString((string)null !));
}
public void IsLeapYearTest()
{
var year = int.Parse(TestContext.DataRow["year"].ToString());
var isLeapYearString = TestContext.DataRow["isLeapYear"].ToString();
bool expected = (isLeapYearString == "1");
var actual = Date.IsLeapYear(year);
Assert.AreEqual(expected, actual, "Input Year:<{0}>.", year);
}
public override double yearFraction(Date d1, Date d2, Date refPeriodStart, Date refPeriodEnd)
{
if (d1 == d2)
{
return(0);
}
if (d1 > d2)
{
return(-yearFraction(d2, d1, null, null));
}
Date newD2 = d2, temp = d2;
double sum = 0;
while (temp > d1)
{
temp = newD2 - TimeUnit.Years;
if (temp.Day == 28 && temp.Month == 2 && Date.IsLeapYear(temp.Year))
{
temp += 1;
}
if (temp >= d1)
{
sum += 1;
newD2 = temp;
}
}
double den = 365;
if (Date.IsLeapYear(newD2.Year))
{
temp = new Date(29, Month.February, newD2.Year);
if (newD2 > temp && d1 <= temp)
{
den += 1;
}
}
else if (Date.IsLeapYear(d1.Year))
{
temp = new Date(29, Month.February, d1.Year);
if (newD2 > temp && d1 <= temp)
{
den += 1;
}
}
return(sum + dayCount(d1, newD2) / den);
}
public void IsLeapYear()
{
// AA2, p.62
Assert.IsTrue(Date.IsLeapYear(900));
Assert.IsTrue(Date.IsLeapYear(1236));
Assert.IsFalse(Date.IsLeapYear(750));
Assert.IsFalse(Date.IsLeapYear(1429));
Assert.IsFalse(Date.IsLeapYear(1700));
Assert.IsFalse(Date.IsLeapYear(1800));
Assert.IsFalse(Date.IsLeapYear(1900));
Assert.IsFalse(Date.IsLeapYear(2100));
Assert.IsTrue(Date.IsLeapYear(1600));
Assert.IsTrue(Date.IsLeapYear(2000));
Assert.IsTrue(Date.IsLeapYear(2400));
}
public void DateProperties()
{
Date date = new Date(1970, 5, 20);
Assert.AreEqual(1970, date.Year);
Assert.AreEqual(5, date.Month);
Assert.AreEqual(20, date.Day);
Assert.AreEqual(DayOfWeek.Wednesday, date.DayOfWeek);
Assert.AreEqual(140, date.DayOfYear);
Assert.AreEqual(28, Date.DaysInMonth(1970, 2));
Assert.AreEqual(29, Date.DaysInMonth(2016, 2));
Assert.IsFalse(Date.IsLeapYear(1900)); // 100-year exception
Assert.IsFalse(Date.IsLeapYear(1970));
Assert.IsTrue(Date.IsLeapYear(1996));
Assert.IsFalse(Date.IsLeapYear(1997));
Assert.IsFalse(Date.IsLeapYear(1998));
Assert.IsFalse(Date.IsLeapYear(1999));
Assert.IsTrue(Date.IsLeapYear(2000)); // 400-year exception
Assert.IsTrue(Date.IsLeapYear(2016));
date = new Date(1900, 5, 20);
Assert.AreEqual(1900, date.Year);
Assert.AreEqual(5, date.Month);
Assert.AreEqual(20, date.Day);
Assert.AreEqual(140, date.DayOfYear);
date = new Date(1999, 5, 20);
Assert.AreEqual(1999, date.Year);
Assert.AreEqual(5, date.Month);
Assert.AreEqual(20, date.Day);
Assert.AreEqual(140, date.DayOfYear);
date = new Date(2000, 5, 20);
Assert.AreEqual(2000, date.Year);
Assert.AreEqual(5, date.Month);
Assert.AreEqual(20, date.Day);
Assert.AreEqual(141, date.DayOfYear);
date = new Date(2000, 5, 20);
int daysSinceStart = date.DaysSinceCalendarStart;
date = new Date(2000, 5, 21);
Assert.AreEqual(daysSinceStart + 1, date.DaysSinceCalendarStart);
}
/// <summary>
/// 两个日期之间的天数
/// </summary>
/// <param name="startDate">开始日</param>
/// <param name="endDate">结束日</param>
/// <returns>天数</returns>
public double DaysInPeriod(Date startDate, Date endDate)
{
var startYear = startDate.Year;
var endYear = endDate.Year;
var excludedDayCount = 0;
for (var year = startYear; year <= endYear; ++year)
{
if (Date.IsLeapYear(year))
{
var leapDate = new Date(year, 2, 29);
if (leapDate.Between(startDate, endDate))
{
++excludedDayCount;
}
}
}
return(endDate - startDate - excludedDayCount);
}
public override double yearFraction(Date d1, Date d2, Date refPeriodStart, Date refPeriodEnd)
{
if (d1 == d2)
{
return(0);
}
if (d1 > d2)
{
return(-yearFraction(d2, d1, null, null));
}
int y1 = d1.Year, y2 = d2.Year;
double dib1 = (Date.IsLeapYear(y1) ? 366 : 365);
double dib2 = (Date.IsLeapYear(y2) ? 366 : 365);
double sum = y2 - y1 - 1;
sum += dayCount(d1, new Date(1, Month.January, y1 + 1)) / dib1;
sum += dayCount(new Date(1, Month.January, y2), d2) / dib2;
return(sum);
}
/// <summary>
/// 通过基准日期和日期差，计算目标日期
/// </summary>
/// <param name="startDate">基准日期</param>
/// <param name="dayCountFraction">日期差</param>
/// <param name="referenceStartDate">参考开始日</param>
/// <param name="referenceEndDate">参考结束日</param>
/// <returns>目标日期</returns>
public Date CalcEndDateFromDayCountFraction(Date startDate, double dayCountFraction, Date referenceStartDate, Date referenceEndDate)
{
var yrs = Convert.ToInt16(dayCountFraction);
var startYear = startDate.Year;
var endYear = startYear + yrs;
var guessEndDate = startDate.AddDays(Convert.ToInt16(dayCountFraction * 365.0));
var includedDayCount = 0;
for (var year = startYear; year <= endYear; ++year)
{
if (Date.IsLeapYear(year))
{
var leapDate = new Date(year, 2, 29);
if (leapDate.Between(startDate, guessEndDate))
{
++includedDayCount;
}
}
}
//Note: potential issue: end day could be (2,28) or (2,29), we return (2,28)
return(startDate.AddDays(Convert.ToInt16(dayCountFraction * 365.0) + includedDayCount));
}
public void testConsistency()
{
//("Testing dates...");
int minDate = Date.minDate().serialNumber() + 1,
maxDate = Date.maxDate().serialNumber();
int dyold = new Date(minDate - 1).DayOfYear,
dold = new Date(minDate - 1).Day,
mold = new Date(minDate - 1).Month,
yold = new Date(minDate - 1).Year,
wdold = new Date(minDate - 1).weekday();
for (int i = minDate; i <= maxDate; i++)
{
Date t = new Date(i);
int serial = t.serialNumber();
// check serial number consistency
if (serial != i)
{
QAssert.Fail("inconsistent serial number:\n"
+ " original: " + i + "\n"
+ " date: " + t + "\n"
+ " serial number: " + serial);
}
int dy = t.DayOfYear,
d = t.Day,
m = t.Month,
y = t.Year,
wd = t.weekday();
// check if skipping any date
if (!((dy == dyold + 1) ||
(dy == 1 && dyold == 365 && !Date.IsLeapYear(yold)) ||
(dy == 1 && dyold == 366 && Date.IsLeapYear(yold))))
{
QAssert.Fail("wrong day of year increment: \n"
+ " date: " + t + "\n"
+ " day of year: " + dy + "\n"
+ " previous: " + dyold);
}
dyold = dy;
if (!((d == dold + 1 && m == mold && y == yold) ||
(d == 1 && m == mold + 1 && y == yold) ||
(d == 1 && m == 1 && y == yold + 1)))
{
QAssert.Fail("wrong day,month,year increment: \n"
+ " date: " + t + "\n"
+ " day,month,year: "
+ d + "," + m + "," + y + "\n"
+ " previous: "
+ dold + "," + mold + "," + yold);
}
dold = d; mold = m; yold = y;
// check month definition
if (m < 1 || m > 12)
{
QAssert.Fail("invalid month: \n"
+ " date: " + t + "\n"
+ " month: " + m);
}
// check day definition
if (d < 1)
{
QAssert.Fail("invalid day of month: \n"
+ " date: " + t + "\n"
+ " day: " + d);
}
if (!((m == 1 && d <= 31) ||
(m == 2 && d <= 28) ||
(m == 2 && d == 29 && Date.IsLeapYear(y)) ||
(m == 3 && d <= 31) ||
(m == 4 && d <= 30) ||
(m == 5 && d <= 31) ||
(m == 6 && d <= 30) ||
(m == 7 && d <= 31) ||
(m == 8 && d <= 31) ||
(m == 9 && d <= 30) ||
(m == 10 && d <= 31) ||
(m == 11 && d <= 30) ||
(m == 12 && d <= 31)))
{
QAssert.Fail("invalid day of month: \n"
+ " date: " + t + "\n"
+ " day: " + d);
}
// check weekday definition
if (!((wd == wdold + 1) ||
(wd == 1 && wdold == 7)))
{
QAssert.Fail("invalid weekday: \n"
+ " date: " + t + "\n"
+ " weekday: " + wd + "\n"
+ " previous: " + wdold);
}
wdold = wd;
// create the same date with a different constructor
Date s = new Date(d, m, y);
// check serial number consistency
serial = s.serialNumber();
if (serial != i)
{
QAssert.Fail("inconsistent serial number:\n"
+ " date: " + t + "\n"
+ " serial number: " + i + "\n"
+ " cloned date: " + s + "\n"
+ " serial number: " + serial);
}
}
}
public void CannotDetermineLeapYear_TooLarge()
{
Assert.Throws <ArgumentOutOfRangeException>(() => Date.IsLeapYear(10000));
}
public void CanDetermineLeapYear_2100()
{
Assert.False(Date.IsLeapYear(2100));
}
public void CanDetermineLeapYear_2004()
{
Assert.True(Date.IsLeapYear(2004));
}
public void CanDetermineLeapYear_2001()
{
Assert.False(Date.IsLeapYear(2001));
}
public void IsLeapYear_ForOrdinalYear_ReturnsFalse()
{
Assert.IsFalse(Date.IsLeapYear(2001));
}
public void IsLeapYear_ForLeapYear_ReturnsTrue()
{
Assert.IsTrue(Date.IsLeapYear(2000));
}
