public void AddTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.Equal(0, dateTimeSet.Count);
dateTimeSet.Add(previousCalendarYear);
Assert.Equal(1, dateTimeSet.Count);
Assert.Equal(dateTimeSet.Min, previousCalendarYear);
Assert.Equal(dateTimeSet.Max, previousCalendarYear);
dateTimeSet.Add(nextCalendarYear);
Assert.Equal(2, dateTimeSet.Count);
Assert.Equal(dateTimeSet.Min, previousCalendarYear);
Assert.Equal(dateTimeSet.Max, nextCalendarYear);
dateTimeSet.Add(currentCalendarYear);
Assert.Equal(3, dateTimeSet.Count);
Assert.Equal(dateTimeSet.Min, previousCalendarYear);
Assert.Equal(dateTimeSet.Max, nextCalendarYear);
dateTimeSet.Add(previousCalendarYear);
Assert.Equal(3, dateTimeSet.Count);
Assert.False(dateTimeSet.Add(previousCalendarYear));
dateTimeSet.Add(currentCalendarYear);
Assert.Equal(3, dateTimeSet.Count);
Assert.False(dateTimeSet.Add(currentCalendarYear));
dateTimeSet.Add(nextCalendarYear);
Assert.Equal(3, dateTimeSet.Count);
Assert.False(dateTimeSet.Add(nextCalendarYear));
} // AddTest
public void AddTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.Count, 0);
dateTimeSet.Add(previousCalendarYear);
Assert.AreEqual(dateTimeSet.Count, 1);
Assert.AreEqual(dateTimeSet.Min, previousCalendarYear);
Assert.AreEqual(dateTimeSet.Max, previousCalendarYear);
dateTimeSet.Add(nextCalendarYear);
Assert.AreEqual(dateTimeSet.Count, 2);
Assert.AreEqual(dateTimeSet.Min, previousCalendarYear);
Assert.AreEqual(dateTimeSet.Max, nextCalendarYear);
dateTimeSet.Add(currentCalendarYear);
Assert.AreEqual(dateTimeSet.Count, 3);
Assert.AreEqual(dateTimeSet.Min, previousCalendarYear);
Assert.AreEqual(dateTimeSet.Max, nextCalendarYear);
dateTimeSet.Add(previousCalendarYear);
Assert.AreEqual(dateTimeSet.Count, 3);
Assert.IsFalse(dateTimeSet.Add(previousCalendarYear));
dateTimeSet.Add(currentCalendarYear);
Assert.AreEqual(dateTimeSet.Count, 3);
Assert.IsFalse(dateTimeSet.Add(currentCalendarYear));
dateTimeSet.Add(nextCalendarYear);
Assert.AreEqual(dateTimeSet.Count, 3);
Assert.IsFalse(dateTimeSet.Add(nextCalendarYear));
} // AddTest
public void AddAllTest()
{
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
List <DateTime> moments = new List <DateTime>
{
nextCalendarYear,
currentCalendarYear,
previousCalendarYear
};
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.Count, 0);
Assert.AreEqual(dateTimeSet.Min, null);
Assert.AreEqual(dateTimeSet.Max, null);
Assert.AreEqual(dateTimeSet.Duration, null);
Assert.IsTrue(dateTimeSet.IsEmpty);
Assert.IsFalse(dateTimeSet.IsMoment);
Assert.IsFalse(dateTimeSet.IsAnytime);
dateTimeSet.AddAll(moments);
Assert.AreEqual(dateTimeSet.Count, moments.Count);
Assert.AreEqual(dateTimeSet.Min, previousCalendarYear);
Assert.AreEqual(dateTimeSet.Max, nextCalendarYear);
Assert.AreEqual(dateTimeSet.Duration, nextCalendarYear - previousCalendarYear);
Assert.IsFalse(dateTimeSet.IsEmpty);
Assert.IsFalse(dateTimeSet.IsMoment);
Assert.IsFalse(dateTimeSet.IsAnytime);
}
public void AddTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears( -1 );
DateTime nextCalendarYear = currentCalendarYear.AddYears( 1 );
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual( dateTimeSet.Count, 0 );
dateTimeSet.Add( previousCalendarYear );
Assert.AreEqual( dateTimeSet.Count, 1 );
Assert.AreEqual( dateTimeSet.Min, previousCalendarYear );
Assert.AreEqual( dateTimeSet.Max, previousCalendarYear );
dateTimeSet.Add( nextCalendarYear );
Assert.AreEqual( dateTimeSet.Count, 2 );
Assert.AreEqual( dateTimeSet.Min, previousCalendarYear );
Assert.AreEqual( dateTimeSet.Max, nextCalendarYear );
dateTimeSet.Add( currentCalendarYear );
Assert.AreEqual( dateTimeSet.Count, 3 );
Assert.AreEqual( dateTimeSet.Min, previousCalendarYear );
Assert.AreEqual( dateTimeSet.Max, nextCalendarYear );
dateTimeSet.Add( previousCalendarYear );
Assert.AreEqual( dateTimeSet.Count, 3 );
Assert.IsFalse( dateTimeSet.Add( previousCalendarYear ) );
dateTimeSet.Add( currentCalendarYear );
Assert.AreEqual( dateTimeSet.Count, 3 );
Assert.IsFalse( dateTimeSet.Add( currentCalendarYear ) );
dateTimeSet.Add( nextCalendarYear );
Assert.AreEqual( dateTimeSet.Count, 3 );
Assert.IsFalse( dateTimeSet.Add( nextCalendarYear ) );
}
public void AddAllTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
List <DateTime> moments = new List <DateTime>();
moments.Add(nextCalendarYear);
moments.Add(currentCalendarYear);
moments.Add(previousCalendarYear);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.Equal(0, dateTimeSet.Count);
Assert.Null(dateTimeSet.Min);
Assert.Null(dateTimeSet.Max);
Assert.Null(dateTimeSet.Duration);
Assert.True(dateTimeSet.IsEmpty);
Assert.False(dateTimeSet.IsMoment);
Assert.False(dateTimeSet.IsAnytime);
dateTimeSet.AddAll(moments);
Assert.Equal(dateTimeSet.Count, moments.Count);
Assert.Equal(dateTimeSet.Min, previousCalendarYear);
Assert.Equal(dateTimeSet.Max, nextCalendarYear);
Assert.Equal(dateTimeSet.Duration, nextCalendarYear - previousCalendarYear);
Assert.False(dateTimeSet.IsEmpty);
Assert.False(dateTimeSet.IsMoment);
Assert.False(dateTimeSet.IsAnytime);
} // AddAllTest
public void AddAllTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears( -1 );
DateTime nextCalendarYear = currentCalendarYear.AddYears( 1 );
List<DateTime> moments = new List<DateTime>();
moments.Add( nextCalendarYear );
moments.Add( currentCalendarYear );
moments.Add( previousCalendarYear );
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual( dateTimeSet.Count, 0 );
Assert.AreEqual( dateTimeSet.Min, null );
Assert.AreEqual( dateTimeSet.Max, null );
Assert.AreEqual( dateTimeSet.Duration, null );
Assert.IsTrue( dateTimeSet.IsEmpty );
Assert.IsFalse( dateTimeSet.IsMoment );
Assert.IsFalse( dateTimeSet.IsAnytime );
dateTimeSet.AddAll( moments );
Assert.AreEqual( dateTimeSet.Count, moments.Count );
Assert.AreEqual( dateTimeSet.Min, previousCalendarYear );
Assert.AreEqual( dateTimeSet.Max, nextCalendarYear );
Assert.AreEqual( dateTimeSet.Duration, nextCalendarYear - previousCalendarYear );
Assert.IsFalse( dateTimeSet.IsEmpty );
Assert.IsFalse( dateTimeSet.IsMoment );
Assert.IsFalse( dateTimeSet.IsAnytime );
}
public void DefaultConstructorTest() {
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.Count, 0);
Assert.AreEqual(dateTimeSet.Min, null);
Assert.AreEqual(dateTimeSet.Max, null);
Assert.AreEqual(dateTimeSet.Duration, null);
Assert.IsTrue(dateTimeSet.IsEmpty);
Assert.IsFalse(dateTimeSet.IsMoment);
Assert.IsFalse(dateTimeSet.IsAnytime);
}
public void DefaultConstructorTest()
{
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.Count, 0);
Assert.AreEqual(dateTimeSet.Min, null);
Assert.AreEqual(dateTimeSet.Max, null);
Assert.AreEqual(dateTimeSet.Duration, null);
Assert.IsTrue(dateTimeSet.IsEmpty);
Assert.IsFalse(dateTimeSet.IsMoment);
Assert.IsFalse(dateTimeSet.IsAnytime);
} // DefaultConstructorTest
public void DefaultConstructorTest()
{
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.Equal(0, dateTimeSet.Count);
Assert.Null(dateTimeSet.Min);
Assert.Null(dateTimeSet.Max);
Assert.Null(dateTimeSet.Duration);
Assert.True(dateTimeSet.IsEmpty);
Assert.False(dateTimeSet.IsMoment);
Assert.False(dateTimeSet.IsAnytime);
} // DefaultConstructorTest
public void ItemTest() {
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
dateTimeSet.Add(nextCalendarYear);
dateTimeSet.Add(currentCalendarYear);
dateTimeSet.Add(previousCalendarYear);
Assert.AreEqual(dateTimeSet[0], previousCalendarYear);
Assert.AreEqual(dateTimeSet[1], currentCalendarYear);
Assert.AreEqual(dateTimeSet[2], nextCalendarYear);
}
public void MaxTest() {
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.Max, null);
dateTimeSet.Add(currentCalendarYear);
Assert.AreEqual(dateTimeSet.Max, currentCalendarYear);
dateTimeSet.Add(nextCalendarYear);
Assert.AreEqual(dateTimeSet.Max, nextCalendarYear);
dateTimeSet.Clear();
Assert.AreEqual(dateTimeSet.Max, null);
}
public void MinTest() {
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.Min, null);
dateTimeSet.Add(currentCalendarYear);
Assert.AreEqual(dateTimeSet.Min, currentCalendarYear);
dateTimeSet.Add(previousCalendarYear);
Assert.AreEqual(dateTimeSet.Min, previousCalendarYear);
dateTimeSet.Clear();
Assert.AreEqual(dateTimeSet.Min, null);
}
public void ItemTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
dateTimeSet.Add(nextCalendarYear);
dateTimeSet.Add(currentCalendarYear);
dateTimeSet.Add(previousCalendarYear);
Assert.Equal(dateTimeSet[0], previousCalendarYear);
Assert.Equal(dateTimeSet[1], currentCalendarYear);
Assert.Equal(dateTimeSet[2], nextCalendarYear);
} // ItemTest
public void MinTest()
{
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.Min, null);
dateTimeSet.Add(currentCalendarYear);
Assert.AreEqual(dateTimeSet.Min, currentCalendarYear);
dateTimeSet.Add(previousCalendarYear);
Assert.AreEqual(dateTimeSet.Min, previousCalendarYear);
dateTimeSet.Clear();
Assert.AreEqual(dateTimeSet.Min, null);
}
public void MinTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.Null(dateTimeSet.Min);
dateTimeSet.Add(currentCalendarYear);
Assert.Equal(dateTimeSet.Min, currentCalendarYear);
dateTimeSet.Add(previousCalendarYear);
Assert.Equal(dateTimeSet.Min, previousCalendarYear);
dateTimeSet.Clear();
Assert.Null(dateTimeSet.Min);
} // MinTest
public void MaxTest()
{
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.Max, null);
dateTimeSet.Add(currentCalendarYear);
Assert.AreEqual(dateTimeSet.Max, currentCalendarYear);
dateTimeSet.Add(nextCalendarYear);
Assert.AreEqual(dateTimeSet.Max, nextCalendarYear);
dateTimeSet.Clear();
Assert.AreEqual(dateTimeSet.Max, null);
}
public void MaxTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.Null(dateTimeSet.Max);
dateTimeSet.Add(currentCalendarYear);
Assert.Equal(dateTimeSet.Max, currentCalendarYear);
dateTimeSet.Add(nextCalendarYear);
Assert.Equal(dateTimeSet.Max, nextCalendarYear);
dateTimeSet.Clear();
Assert.Null(dateTimeSet.Max);
} // MaxTest
public void CopyToTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
dateTimeSet.Add(nextCalendarYear);
dateTimeSet.Add(currentCalendarYear);
dateTimeSet.Add(previousCalendarYear);
DateTime[] array = new DateTime[3];
dateTimeSet.CopyTo(array, 0);
Assert.Equal(array[0], previousCalendarYear);
Assert.Equal(array[1], currentCalendarYear);
Assert.Equal(array[2], nextCalendarYear);
} // CopyToTest
public void IsAnytimeTest()
{
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.False(dateTimeSet.IsAnytime);
dateTimeSet.Add(DateTime.MinValue);
Assert.False(dateTimeSet.IsAnytime);
dateTimeSet.Add(DateTime.MaxValue);
Assert.True(dateTimeSet.IsAnytime);
dateTimeSet.Remove(DateTime.MinValue);
Assert.False(dateTimeSet.IsAnytime);
dateTimeSet.Clear();
Assert.False(dateTimeSet.IsAnytime);
} // IsAnytimeTest
public void ClearTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.Count, 0);
dateTimeSet.Add(previousCalendarYear);
Assert.AreEqual(dateTimeSet.Count, 1);
dateTimeSet.Add(nextCalendarYear);
Assert.AreEqual(dateTimeSet.Count, 2);
dateTimeSet.Add(currentCalendarYear);
Assert.AreEqual(dateTimeSet.Count, 3);
dateTimeSet.Clear();
Assert.AreEqual(dateTimeSet.Count, 0);
} // ClearTest
public void ClearTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.Equal(0, dateTimeSet.Count);
dateTimeSet.Add(previousCalendarYear);
Assert.Equal(1, dateTimeSet.Count);
dateTimeSet.Add(nextCalendarYear);
Assert.Equal(2, dateTimeSet.Count);
dateTimeSet.Add(currentCalendarYear);
Assert.Equal(3, dateTimeSet.Count);
dateTimeSet.Clear();
Assert.Equal(0, dateTimeSet.Count);
} // ClearTest
public void CopyToTest()
{
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet
{
nextCalendarYear,
currentCalendarYear,
previousCalendarYear
};
DateTime[] array = new DateTime[3];
dateTimeSet.CopyTo(array, 0);
Assert.AreEqual(array[0], previousCalendarYear);
Assert.AreEqual(array[1], currentCalendarYear);
Assert.AreEqual(array[2], nextCalendarYear);
}
public void IndexOfTest()
{
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.IndexOf(currentCalendarYear), -1);
Assert.AreEqual(dateTimeSet.IndexOf(previousCalendarYear), -1);
Assert.AreEqual(dateTimeSet.IndexOf(nextCalendarYear), -1);
dateTimeSet.Add(previousCalendarYear);
dateTimeSet.Add(nextCalendarYear);
dateTimeSet.Add(currentCalendarYear);
Assert.AreEqual(dateTimeSet.IndexOf(previousCalendarYear), 0);
Assert.AreEqual(dateTimeSet.IndexOf(currentCalendarYear), 1);
Assert.AreEqual(dateTimeSet.IndexOf(nextCalendarYear), 2);
}
public void CopyConstructorTest() {
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
List<DateTime> moments = new List<DateTime>();
moments.Add(nextCalendarYear);
moments.Add(previousCalendarYear);
moments.Add(currentCalendarYear);
DateTimeSet dateTimeSet = new DateTimeSet(moments);
Assert.AreEqual(dateTimeSet.Count, moments.Count);
Assert.AreEqual(dateTimeSet.Min, previousCalendarYear);
Assert.AreEqual(dateTimeSet.Max, nextCalendarYear);
Assert.AreEqual(dateTimeSet.Duration, nextCalendarYear - previousCalendarYear);
Assert.IsFalse(dateTimeSet.IsEmpty);
Assert.IsFalse(dateTimeSet.IsMoment);
Assert.IsFalse(dateTimeSet.IsAnytime);
}
public void IndexOfTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.Equal(dateTimeSet.IndexOf(currentCalendarYear), -1);
Assert.Equal(dateTimeSet.IndexOf(previousCalendarYear), -1);
Assert.Equal(dateTimeSet.IndexOf(nextCalendarYear), -1);
dateTimeSet.Add(previousCalendarYear);
dateTimeSet.Add(nextCalendarYear);
dateTimeSet.Add(currentCalendarYear);
Assert.Equal(0, dateTimeSet.IndexOf(previousCalendarYear));
Assert.Equal(1, dateTimeSet.IndexOf(currentCalendarYear));
Assert.Equal(2, dateTimeSet.IndexOf(nextCalendarYear));
} // IndexOfTest
public void IsMomentTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.False(dateTimeSet.IsMoment);
dateTimeSet.Add(currentCalendarYear);
Assert.True(dateTimeSet.IsMoment);
dateTimeSet.Add(nextCalendarYear);
Assert.False(dateTimeSet.IsMoment);
dateTimeSet.Remove(nextCalendarYear);
Assert.True(dateTimeSet.IsMoment);
dateTimeSet.Clear();
Assert.False(dateTimeSet.IsMoment);
} // IsMomentTest
public void IsEmptyTest()
{
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.IsTrue(dateTimeSet.IsEmpty);
dateTimeSet.Add(currentCalendarYear);
Assert.IsFalse(dateTimeSet.IsEmpty);
dateTimeSet.Add(nextCalendarYear);
Assert.IsFalse(dateTimeSet.IsEmpty);
dateTimeSet.Remove(nextCalendarYear);
Assert.IsFalse(dateTimeSet.IsEmpty);
dateTimeSet.Clear();
Assert.IsTrue(dateTimeSet.IsEmpty);
}
public void DurationTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.Null(dateTimeSet.Duration);
dateTimeSet.Add(currentCalendarYear);
Assert.Equal(dateTimeSet.Duration, TimeSpan.Zero);
dateTimeSet.Add(nextCalendarYear);
Assert.Equal(dateTimeSet.Duration, nextCalendarYear - currentCalendarYear);
dateTimeSet.Remove(nextCalendarYear);
Assert.Equal(dateTimeSet.Duration, TimeSpan.Zero);
dateTimeSet.Clear();
Assert.Null(dateTimeSet.Duration);
} // DurationTest
public void CopyConstructorTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
List <DateTime> moments = new List <DateTime>();
moments.Add(nextCalendarYear);
moments.Add(previousCalendarYear);
moments.Add(currentCalendarYear);
DateTimeSet dateTimeSet = new DateTimeSet(moments);
Assert.Equal <int>(dateTimeSet.Count, moments.Count);
Assert.Equal(dateTimeSet.Min, previousCalendarYear);
Assert.Equal(dateTimeSet.Max, nextCalendarYear);
Assert.Equal(dateTimeSet.Duration, nextCalendarYear - previousCalendarYear);
Assert.False(dateTimeSet.IsEmpty);
Assert.False(dateTimeSet.IsMoment);
Assert.False(dateTimeSet.IsAnytime);
} // CopyConstructorTest
public void RemoveTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.False(dateTimeSet.Contains(previousCalendarYear));
dateTimeSet.Add(previousCalendarYear);
Assert.True(dateTimeSet.Contains(previousCalendarYear));
dateTimeSet.Remove(previousCalendarYear);
Assert.False(dateTimeSet.Contains(previousCalendarYear));
Assert.False(dateTimeSet.Contains(nextCalendarYear));
dateTimeSet.Add(nextCalendarYear);
Assert.True(dateTimeSet.Contains(nextCalendarYear));
dateTimeSet.Remove(previousCalendarYear);
Assert.True(dateTimeSet.Contains(nextCalendarYear));
} // RemoveTest
public void FindNextTest()
{
DateTime now = ClockProxy.Clock.Now;
DateTime currentCalendarYear = Now.CalendarYear;
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.Null(dateTimeSet.FindNext(now));
dateTimeSet.Add(currentCalendarYear);
Assert.Null(dateTimeSet.FindNext(now));
dateTimeSet.Add(nextCalendarYear);
Assert.Equal(dateTimeSet.FindNext(now), nextCalendarYear);
Assert.Equal(dateTimeSet.FindNext(currentCalendarYear), nextCalendarYear);
dateTimeSet.Remove(currentCalendarYear);
Assert.Equal(dateTimeSet.FindNext(now), nextCalendarYear);
dateTimeSet.Remove(nextCalendarYear);
Assert.Null(dateTimeSet.FindNext(now));
} // FindNextTest
public void FindPreviousTest()
{
DateTime now = ClockProxy.Clock.Now;
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.Null(dateTimeSet.FindPrevious(now));
dateTimeSet.Add(currentCalendarYear);
Assert.Equal(dateTimeSet.FindPrevious(now), now == currentCalendarYear ? (DateTime?)null : currentCalendarYear);
dateTimeSet.Add(previousCalendarYear);
Assert.Equal(dateTimeSet.FindPrevious(now), now == currentCalendarYear ? previousCalendarYear : currentCalendarYear);
Assert.Equal(dateTimeSet.FindPrevious(currentCalendarYear), previousCalendarYear);
dateTimeSet.Remove(currentCalendarYear);
Assert.Equal(dateTimeSet.FindPrevious(now), previousCalendarYear);
dateTimeSet.Remove(previousCalendarYear);
Assert.Null(dateTimeSet.FindPrevious(now));
} // FindPreviousTest
public void ContainsTest()
{
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.IsFalse(dateTimeSet.Contains(currentCalendarYear));
Assert.IsFalse(dateTimeSet.Contains(previousCalendarYear));
Assert.IsFalse(dateTimeSet.Contains(nextCalendarYear));
dateTimeSet.Add(previousCalendarYear);
Assert.IsFalse(dateTimeSet.Contains(currentCalendarYear));
Assert.IsTrue(dateTimeSet.Contains(previousCalendarYear));
Assert.IsFalse(dateTimeSet.Contains(nextCalendarYear));
dateTimeSet.Add(nextCalendarYear);
Assert.IsFalse(dateTimeSet.Contains(currentCalendarYear));
Assert.IsTrue(dateTimeSet.Contains(previousCalendarYear));
Assert.IsTrue(dateTimeSet.Contains(nextCalendarYear));
dateTimeSet.Add(currentCalendarYear);
Assert.IsTrue(dateTimeSet.Contains(currentCalendarYear));
Assert.IsTrue(dateTimeSet.Contains(previousCalendarYear));
Assert.IsTrue(dateTimeSet.Contains(nextCalendarYear));
dateTimeSet.Remove(nextCalendarYear);
Assert.IsTrue(dateTimeSet.Contains(currentCalendarYear));
Assert.IsTrue(dateTimeSet.Contains(previousCalendarYear));
Assert.IsFalse(dateTimeSet.Contains(nextCalendarYear));
dateTimeSet.Clear();
Assert.IsFalse(dateTimeSet.Contains(currentCalendarYear));
Assert.IsFalse(dateTimeSet.Contains(previousCalendarYear));
Assert.IsFalse(dateTimeSet.Contains(nextCalendarYear));
}
public void GetDurationsTest()
{
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarMonth = currentCalendarYear.AddMonths(-1);
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarMonth = currentCalendarYear.AddMonths(1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet
{
currentCalendarYear,
nextCalendarYear,
nextCalendarMonth,
previousCalendarYear,
previousCalendarMonth
};
IList <TimeSpan> durations1 = dateTimeSet.GetDurations(0, dateTimeSet.Count);
Assert.AreEqual(durations1.Count, 4);
Assert.AreEqual(durations1[0], previousCalendarMonth - previousCalendarYear);
Assert.AreEqual(durations1[1], currentCalendarYear - previousCalendarMonth);
Assert.AreEqual(durations1[2], nextCalendarMonth - currentCalendarYear);
Assert.AreEqual(durations1[3], nextCalendarYear - nextCalendarMonth);
IList <TimeSpan> durations2 = dateTimeSet.GetDurations(1, 2);
Assert.AreEqual(durations2.Count, 2);
Assert.AreEqual(durations2[0], currentCalendarYear - previousCalendarMonth);
Assert.AreEqual(durations2[1], nextCalendarMonth - currentCalendarYear);
IList <TimeSpan> durations3 = dateTimeSet.GetDurations(2, dateTimeSet.Count);
Assert.AreEqual(durations3.Count, 2);
Assert.AreEqual(durations3[0], nextCalendarMonth - currentCalendarYear);
Assert.AreEqual(durations3[1], nextCalendarYear - nextCalendarMonth);
}
public void GetDurationsTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime previousCalendarMonth = currentCalendarYear.AddMonths(-1);
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarMonth = currentCalendarYear.AddMonths(1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
dateTimeSet.Add(currentCalendarYear);
dateTimeSet.Add(nextCalendarYear);
dateTimeSet.Add(nextCalendarMonth);
dateTimeSet.Add(previousCalendarYear);
dateTimeSet.Add(previousCalendarMonth);
IList <TimeSpan> durations1 = dateTimeSet.GetDurations(0, dateTimeSet.Count);
Assert.Equal(4, durations1.Count);
Assert.Equal(durations1[0], previousCalendarMonth - previousCalendarYear);
Assert.Equal(durations1[1], currentCalendarYear - previousCalendarMonth);
Assert.Equal(durations1[2], nextCalendarMonth - currentCalendarYear);
Assert.Equal(durations1[3], nextCalendarYear - nextCalendarMonth);
IList <TimeSpan> durations2 = dateTimeSet.GetDurations(1, 2);
Assert.Equal(2, durations2.Count);
Assert.Equal(durations2[0], currentCalendarYear - previousCalendarMonth);
Assert.Equal(durations2[1], nextCalendarMonth - currentCalendarYear);
IList <TimeSpan> durations3 = dateTimeSet.GetDurations(2, dateTimeSet.Count);
Assert.Equal(2, durations3.Count);
Assert.Equal(durations3[0], nextCalendarMonth - currentCalendarYear);
Assert.Equal(durations3[1], nextCalendarYear - nextCalendarMonth);
} // GetDurationsTest
public void CountTest()
{
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.Count, 0);
dateTimeSet.Add(DateTime.MinValue);
Assert.AreEqual(dateTimeSet.Count, 1);
dateTimeSet.Add(DateTime.MinValue);
Assert.AreEqual(dateTimeSet.Count, 1);
dateTimeSet.Add(DateTime.MaxValue);
Assert.AreEqual(dateTimeSet.Count, 2);
dateTimeSet.Add(DateTime.MaxValue);
Assert.AreEqual(dateTimeSet.Count, 2);
dateTimeSet.Remove(DateTime.MinValue);
Assert.AreEqual(dateTimeSet.Count, 1);
dateTimeSet.Clear();
Assert.AreEqual(dateTimeSet.Count, 0);
} // CountTest
public void CountTest()
{
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.Equal(0, dateTimeSet.Count);
dateTimeSet.Add(DateTime.MinValue);
Assert.Equal(1, dateTimeSet.Count);
dateTimeSet.Add(DateTime.MinValue);
Assert.Equal(1, dateTimeSet.Count);
dateTimeSet.Add(DateTime.MaxValue);
Assert.Equal(2, dateTimeSet.Count);
dateTimeSet.Add(DateTime.MaxValue);
Assert.Equal(2, dateTimeSet.Count);
dateTimeSet.Remove(DateTime.MinValue);
Assert.Equal(1, dateTimeSet.Count);
dateTimeSet.Clear();
Assert.Equal(0, dateTimeSet.Count);
} // CountTest
public void IsEmptyTest()
{
DateTime currentCalendarYear = Now.CalendarYear;
DateTime nextCalendarYear = currentCalendarYear.AddYears( 1 );
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.IsTrue( dateTimeSet.IsEmpty );
dateTimeSet.Add( currentCalendarYear );
Assert.IsFalse( dateTimeSet.IsEmpty );
dateTimeSet.Add( nextCalendarYear );
Assert.IsFalse( dateTimeSet.IsEmpty );
dateTimeSet.Remove( nextCalendarYear );
Assert.IsFalse( dateTimeSet.IsEmpty );
dateTimeSet.Clear();
Assert.IsTrue( dateTimeSet.IsEmpty );
}
public void CopyToTest() {
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet
{
nextCalendarYear,
currentCalendarYear,
previousCalendarYear
};
DateTime[] array = new DateTime[3];
dateTimeSet.CopyTo(array, 0);
Assert.AreEqual(array[0], previousCalendarYear);
Assert.AreEqual(array[1], currentCalendarYear);
Assert.AreEqual(array[2], nextCalendarYear);
}
public void IsAnytimeTest() {
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.IsFalse(dateTimeSet.IsAnytime);
dateTimeSet.Add(DateTime.MinValue);
Assert.IsFalse(dateTimeSet.IsAnytime);
dateTimeSet.Add(DateTime.MaxValue);
Assert.IsTrue(dateTimeSet.IsAnytime);
dateTimeSet.Remove(DateTime.MinValue);
Assert.IsFalse(dateTimeSet.IsAnytime);
dateTimeSet.Clear();
Assert.IsFalse(dateTimeSet.IsAnytime);
}
public void CountTest() {
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.Count, 0);
dateTimeSet.Add(DateTime.MinValue);
Assert.AreEqual(dateTimeSet.Count, 1);
dateTimeSet.Add(DateTime.MinValue);
Assert.AreEqual(dateTimeSet.Count, 1);
dateTimeSet.Add(DateTime.MaxValue);
Assert.AreEqual(dateTimeSet.Count, 2);
dateTimeSet.Add(DateTime.MaxValue);
Assert.AreEqual(dateTimeSet.Count, 2);
dateTimeSet.Remove(DateTime.MinValue);
Assert.AreEqual(dateTimeSet.Count, 1);
dateTimeSet.Clear();
Assert.AreEqual(dateTimeSet.Count, 0);
}
public void IndexOfTest() {
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.IndexOf(currentCalendarYear), -1);
Assert.AreEqual(dateTimeSet.IndexOf(previousCalendarYear), -1);
Assert.AreEqual(dateTimeSet.IndexOf(nextCalendarYear), -1);
dateTimeSet.Add(previousCalendarYear);
dateTimeSet.Add(nextCalendarYear);
dateTimeSet.Add(currentCalendarYear);
Assert.AreEqual(dateTimeSet.IndexOf(previousCalendarYear), 0);
Assert.AreEqual(dateTimeSet.IndexOf(currentCalendarYear), 1);
Assert.AreEqual(dateTimeSet.IndexOf(nextCalendarYear), 2);
}
public void FindPreviousTest() {
DateTime now = ClockProxy.Clock.Now;
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.FindPrevious(now), null);
dateTimeSet.Add(currentCalendarYear);
Assert.AreEqual(dateTimeSet.FindPrevious(now), now == currentCalendarYear ? (DateTime?)null : currentCalendarYear);
dateTimeSet.Add(previousCalendarYear);
Assert.AreEqual(dateTimeSet.FindPrevious(now), now == currentCalendarYear ? previousCalendarYear : currentCalendarYear);
Assert.AreEqual(dateTimeSet.FindPrevious(currentCalendarYear), previousCalendarYear);
dateTimeSet.Remove(currentCalendarYear);
Assert.AreEqual(dateTimeSet.FindPrevious(now), previousCalendarYear);
dateTimeSet.Remove(previousCalendarYear);
Assert.AreEqual(dateTimeSet.FindPrevious(now), null);
}
public void FindNextTest() {
DateTime now = ClockProxy.Clock.Now;
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.FindNext(now), null);
dateTimeSet.Add(currentCalendarYear);
Assert.AreEqual(dateTimeSet.FindNext(now), null);
dateTimeSet.Add(nextCalendarYear);
Assert.AreEqual(dateTimeSet.FindNext(now), nextCalendarYear);
Assert.AreEqual(dateTimeSet.FindNext(currentCalendarYear), nextCalendarYear);
dateTimeSet.Remove(currentCalendarYear);
Assert.AreEqual(dateTimeSet.FindNext(now), nextCalendarYear);
dateTimeSet.Remove(nextCalendarYear);
Assert.AreEqual(dateTimeSet.FindNext(now), null);
}
public void DurationTest() {
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.Duration, null);
dateTimeSet.Add(currentCalendarYear);
Assert.AreEqual(dateTimeSet.Duration, TimeSpan.Zero);
dateTimeSet.Add(nextCalendarYear);
Assert.AreEqual(dateTimeSet.Duration, nextCalendarYear - currentCalendarYear);
dateTimeSet.Remove(nextCalendarYear);
Assert.AreEqual(dateTimeSet.Duration, TimeSpan.Zero);
dateTimeSet.Clear();
Assert.AreEqual(dateTimeSet.Duration, null);
}
public void IsMomentTest() {
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.IsFalse(dateTimeSet.IsMoment);
dateTimeSet.Add(currentCalendarYear);
Assert.IsTrue(dateTimeSet.IsMoment);
dateTimeSet.Add(nextCalendarYear);
Assert.IsFalse(dateTimeSet.IsMoment);
dateTimeSet.Remove(nextCalendarYear);
Assert.IsTrue(dateTimeSet.IsMoment);
dateTimeSet.Clear();
Assert.IsFalse(dateTimeSet.IsMoment);
}
public void GetDurationsTest() {
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarMonth = currentCalendarYear.AddMonths(-1);
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarMonth = currentCalendarYear.AddMonths(1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet
{
currentCalendarYear,
nextCalendarYear,
nextCalendarMonth,
previousCalendarYear,
previousCalendarMonth
};
IList<TimeSpan> durations1 = dateTimeSet.GetDurations(0, dateTimeSet.Count);
Assert.AreEqual(durations1.Count, 4);
Assert.AreEqual(durations1[0], previousCalendarMonth - previousCalendarYear);
Assert.AreEqual(durations1[1], currentCalendarYear - previousCalendarMonth);
Assert.AreEqual(durations1[2], nextCalendarMonth - currentCalendarYear);
Assert.AreEqual(durations1[3], nextCalendarYear - nextCalendarMonth);
IList<TimeSpan> durations2 = dateTimeSet.GetDurations(1, 2);
Assert.AreEqual(durations2.Count, 2);
Assert.AreEqual(durations2[0], currentCalendarYear - previousCalendarMonth);
Assert.AreEqual(durations2[1], nextCalendarMonth - currentCalendarYear);
IList<TimeSpan> durations3 = dateTimeSet.GetDurations(2, dateTimeSet.Count);
Assert.AreEqual(durations3.Count, 2);
Assert.AreEqual(durations3[0], nextCalendarMonth - currentCalendarYear);
Assert.AreEqual(durations3[1], nextCalendarYear - nextCalendarMonth);
}
public void RemoveTest() {
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.IsFalse(dateTimeSet.Contains(previousCalendarYear));
dateTimeSet.Add(previousCalendarYear);
Assert.IsTrue(dateTimeSet.Contains(previousCalendarYear));
dateTimeSet.Remove(previousCalendarYear);
Assert.IsFalse(dateTimeSet.Contains(previousCalendarYear));
Assert.IsFalse(dateTimeSet.Contains(nextCalendarYear));
dateTimeSet.Add(nextCalendarYear);
Assert.IsTrue(dateTimeSet.Contains(nextCalendarYear));
dateTimeSet.Remove(previousCalendarYear);
Assert.IsTrue(dateTimeSet.Contains(nextCalendarYear));
}
public void ClearTest() {
DateTime currentCalendarYear = TimeTool.CurrentCalendarYear;
DateTime previousCalendarYear = currentCalendarYear.AddYears(-1);
DateTime nextCalendarYear = currentCalendarYear.AddYears(1);
DateTimeSet dateTimeSet = new DateTimeSet();
Assert.AreEqual(dateTimeSet.Count, 0);
dateTimeSet.Add(previousCalendarYear);
Assert.AreEqual(dateTimeSet.Count, 1);
dateTimeSet.Add(nextCalendarYear);
Assert.AreEqual(dateTimeSet.Count, 2);
dateTimeSet.Add(currentCalendarYear);
Assert.AreEqual(dateTimeSet.Count, 3);
dateTimeSet.Clear();
Assert.AreEqual(dateTimeSet.Count, 0);
}
public void DateTimeSetSample()
{
DateTimeSet moments = new DateTimeSet();
// --- add ---
moments.Add( new DateTime( 2012, 8, 10, 18, 15, 0 ) );
moments.Add( new DateTime( 2012, 8, 10, 15, 0, 0 ) );
moments.Add( new DateTime( 2012, 8, 10, 13, 30, 0 ) );
moments.Add( new DateTime( 2012, 8, 10, 15, 0, 0 ) ); // twice -> ignored
Console.WriteLine( "DateTimeSet.Add(): " + moments );
// > DateTimeSet.Add(): Count = 3; 10.08.2012 13:30:00 - 18:15:00 | 0.04:45
for ( int i = 0; i < moments.Count; i++ )
{
Console.WriteLine( "Moment[{0:0}]: {1}", i, moments[ i ] );
}
// > Moment[0]: 10.08.2012 13:30:00
// > Moment[1]: 10.08.2012 15:00:00
// > Moment[2]: 10.08.2012 18:15:00
// --- durations ---
IList<TimeSpan> durations = moments.GetDurations( 0, moments.Count );
Console.WriteLine( "DateTimeSet.GetDurations() " );
for ( int i = 0; i < durations.Count; i++ )
{
Console.WriteLine( "Duration[{0:0}]: {1}", i, durations[ i ] );
}
// > Duration[0]: 01:30:00
// > Duration[1]: 03:15:00
}
