public void InsertReadOnlyTest()
{
TimePeriodChain timePeriods = new TimePeriodChain();
Assert.NotNull(Assert.Throws <NotSupportedException>(() =>
timePeriods.Insert(0, new TimeRange(TimeSpec.MinPeriodDate, TimeSpec.MaxPeriodDate, true))));
} // InsertReadOnlyTest
public void InsertReadOnlyTest()
{
var timePeriods = new TimePeriodChain();
Assert.Throws <InvalidOperationException>(
() => timePeriods.Insert(0, new TimeRange(TimeSpec.MinPeriodTime, TimeSpec.MaxPeriodTime, true)));
}
public void IsMomentTest()
{
var now = ClockProxy.Clock.Now;
var chain = new TimePeriodChain();
chain.IsMoment.Should().Be.False();
chain.Add(new TimeBlock(now));
chain.Count.Should().Be(1);
chain.HasStart.Should().Be.True();
chain.HasEnd.Should().Be.True();
chain.HasPeriod.Should().Be.True();
chain.IsMoment.Should().Be.True();
chain.IsAnytime.Should().Be.False();
chain.Add(new TimeBlock(now.AddDays(1)));
chain.Count.Should().Be(2);
chain.HasStart.Should().Be.True();
chain.HasEnd.Should().Be.True();
chain.HasPeriod.Should().Be.True();
chain.IsMoment.Should().Be.True();
chain.IsAnytime.Should().Be.False();
chain.Add(new TimeBlock(now, TimeSpan.FromDays(1)));
chain.Count.Should().Be(3);
chain.HasStart.Should().Be.True();
chain.HasEnd.Should().Be.True();
chain.HasPeriod.Should().Be.True();
chain.IsMoment.Should().Be.False();
chain.IsAnytime.Should().Be.False();
}
public void CopyToTest()
{
TimePeriodChain timePeriods = new TimePeriodChain();
ITimePeriod[] array1 = new ITimePeriod[0];
timePeriods.CopyTo(array1, 0);
SchoolDay schoolDay = new SchoolDay();
ITimePeriod[] array2 = new ITimePeriod[schoolDay.Count];
schoolDay.CopyTo(array2, 0);
Assert.Equal(array2[0], schoolDay.Lesson1);
Assert.Equal(array2[1], schoolDay.Break1);
Assert.Equal(array2[2], schoolDay.Lesson2);
Assert.Equal(array2[3], schoolDay.Break2);
Assert.Equal(array2[4], schoolDay.Lesson3);
Assert.Equal(array2[5], schoolDay.Break3);
Assert.Equal(array2[6], schoolDay.Lesson4);
ITimePeriod[] array3 = new ITimePeriod[schoolDay.Count + 3];
schoolDay.CopyTo(array3, 3);
Assert.Equal(array3[3], schoolDay.Lesson1);
Assert.Equal(array3[4], schoolDay.Break1);
Assert.Equal(array3[5], schoolDay.Lesson2);
Assert.Equal(array3[6], schoolDay.Break2);
Assert.Equal(array3[7], schoolDay.Lesson3);
Assert.Equal(array3[8], schoolDay.Break3);
Assert.Equal(array3[9], schoolDay.Lesson4);
} // CopyToTest
// ----------------------------------------------------------------------
public void TimePeriodChainSample()
{
TimePeriodChain timePeriods = new TimePeriodChain();
DateTime now = ClockProxy.Clock.Now;
DateTime testDay = new DateTime(2010, 7, 23);
// --- add ---
timePeriods.Add(new TimeBlock(TimeTrim.Hour(testDay, 8), Duration.Hours(2)));
timePeriods.Add(new TimeBlock(now, Duration.Hours(1, 30)));
timePeriods.Add(new TimeBlock(now, Duration.Hour));
Console.WriteLine("TimePeriodChain.Add(): " + timePeriods);
// > TimePeriodChain.Add(): Count = 3; 23.07.2010 08:00:00 - 12:30:00 | 0.04:30
foreach (ITimePeriod timePeriod in timePeriods)
{
Console.WriteLine("Item: " + timePeriod);
}
// > Item: 23.07.2010 08:00:00 - 10:00:00 | 02:00:00
// > Item: 23.07.2010 10:00:00 - 11:30:00 | 01:30:00
// > Item: 23.07.2010 11:30:00 - 12:30:00 | 01:00:00
// --- insert ---
timePeriods.Insert(2, new TimeBlock(now, Duration.Minutes(45)));
Console.WriteLine("TimePeriodChain.Insert(): " + timePeriods);
// > TimePeriodChain.Insert(): Count = 4; 23.07.2010 08:00:00 - 13:15:00 | 0.05:15
foreach (ITimePeriod timePeriod in timePeriods)
{
Console.WriteLine("Item: " + timePeriod);
}
// > Item: 23.07.2010 08:00:00 - 10:00:00 | 02:00:00
// > Item: 23.07.2010 10:00:00 - 11:30:00 | 01:30:00
// > Item: 23.07.2010 11:30:00 - 12:15:00 | 00:45:00
// > Item: 23.07.2010 12:15:00 - 13:15:00 | 01:00:00
} // TimePeriodChainSample
public void DefaultConstructorTest()
{
TimePeriodChain timePeriods = new TimePeriodChain();
Assert.Equal(0, timePeriods.Count);
Assert.False(timePeriods.HasStart);
Assert.False(timePeriods.HasEnd);
Assert.False(timePeriods.IsReadOnly);
} // DefaultConstructorTest
public void ContainsPeriodTest()
{
var schoolDay = new SchoolDay();
var chain = new TimePeriodChain(schoolDay);
var timeRange = new TimeRange(schoolDay.Lesson1.Start, schoolDay.Lesson1.End);
chain.Contains(timeRange).Should().Be.False();
chain.ContainsPeriod(timeRange).Should().Be.True();
}
public void AddTimeRangeTest()
{
var schoolDay = new SchoolDay();
var chain = new TimePeriodChain(schoolDay);
var range = new TimeRange(schoolDay.Lesson1.Start, schoolDay.Lesson1.End);
chain.Add(range);
chain.Last.Should().Be(range);
}
public void DurationTest()
{
TimePeriodChain timePeriods = new TimePeriodChain();
Assert.Equal(timePeriods.Duration, TimeSpec.MaxPeriodDuration);
TimeSpan duration = Duration.Hour;
timePeriods.Add(new TimeBlock(ClockProxy.Clock.Now, duration));
Assert.Equal <TimeSpan>(timePeriods.Duration, duration);
} // DurationTest
public void ContainsPeriodTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
TimePeriodChain timePeriods = new TimePeriodChain(schoolDay);
TimeRange timeRange = new TimeRange(schoolDay.Lesson1.Start, schoolDay.Lesson1.End);
Assert.False(timePeriods.Contains(timeRange));
Assert.True(timePeriods.ContainsPeriod(timeRange));
} // ContainsPeriodTest
public void InsertTimeRangeTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
TimePeriodChain timePeriods = new TimePeriodChain(schoolDay);
TimeRange timeRange = new TimeRange(schoolDay.Lesson1.Start, schoolDay.Lesson1.End);
timePeriods.Add(timeRange);
Assert.Equal(timePeriods.Last, timeRange);
} // InsertTimeRangeTest
public void DefaultConstructorTest() {
var periodChain = new TimePeriodChain();
periodChain.Count.Should().Be(0);
periodChain.HasStart.Should().Be.False();
periodChain.HasEnd.Should().Be.False();
periodChain.HasPeriod.Should().Be.False();
periodChain.IsReadOnly.Should().Be.False();
periodChain.IsMoment.Should().Be.False();
periodChain.IsAnytime.Should().Be.True();
}
public void CopyConstructorTest()
{
SchoolDay schoolDay = new SchoolDay();
TimePeriodChain timePeriods = new TimePeriodChain(schoolDay);
Assert.Equal(timePeriods.Count, schoolDay.Count);
Assert.True(timePeriods.HasStart);
Assert.True(timePeriods.HasEnd);
Assert.False(timePeriods.IsReadOnly);
Assert.Equal(timePeriods.Start, schoolDay.Start);
} // CopyConstructorTest
public void CopyConstructorTest() {
var schoolDay = new SchoolDay();
var copyChain = new TimePeriodChain(schoolDay);
copyChain.Count.Should().Be(schoolDay.Count);
copyChain.HasStart.Should().Be(schoolDay.HasStart);
copyChain.HasEnd.Should().Be(schoolDay.HasEnd);
copyChain.IsReadOnly.Should().Be(schoolDay.IsReadOnly);
copyChain.Start.Should().Be(schoolDay.Start);
copyChain.End.Should().Be(schoolDay.End);
copyChain.Duration.Should().Be(schoolDay.Duration);
}
public void IsAnytimeTest()
{
DateTime now = ClockProxy.Clock.Now;
TimePeriodChain timePeriods = new TimePeriodChain();
Assert.True(timePeriods.IsAnytime);
timePeriods.Add(new TimeBlock(TimeSpec.MinPeriodDate, now));
Assert.False(timePeriods.IsAnytime);
timePeriods.Add(new TimeBlock(now, TimeSpec.MaxPeriodDate));
Assert.True(timePeriods.IsAnytime);
} // IsAnytimeTest
public void StartTest()
{
DateTime now = ClockProxy.Clock.Now;
TimePeriodChain timePeriods = new TimePeriodChain();
Assert.Equal(timePeriods.Start, TimeSpec.MinPeriodDate);
timePeriods.Add(new TimeBlock(now, Duration.Hour));
Assert.Equal <DateTime>(timePeriods.Start, now);
timePeriods.Clear();
Assert.Equal(timePeriods.Start, TimeSpec.MinPeriodDate);
} // StartTest
public void DefaultConstructorTest()
{
var periodChain = new TimePeriodChain();
periodChain.Count.Should().Be(0);
periodChain.HasStart.Should().Be.False();
periodChain.HasEnd.Should().Be.False();
periodChain.HasPeriod.Should().Be.False();
periodChain.IsReadOnly.Should().Be.False();
periodChain.IsMoment.Should().Be.False();
periodChain.IsAnytime.Should().Be.True();
}
public void EndTest()
{
DateTime now = ClockProxy.Clock.Now;
TimePeriodChain timePeriods = new TimePeriodChain();
Assert.Equal(timePeriods.End, TimeSpec.MaxPeriodDate);
timePeriods.Add(new TimeBlock(Duration.Hour, now));
Assert.Equal <DateTime>(timePeriods.End, now);
timePeriods.Clear();
Assert.Equal(timePeriods.End, TimeSpec.MaxPeriodDate);
} // EndTest
public void DurationTest()
{
var chain = new TimePeriodChain();
chain.Duration.Should().Be(TimeSpec.MaxPeriodDuration);
chain.Add(new TimeBlock(ClockProxy.Clock.Now, DurationUtil.Hour));
chain.Duration.Should().Be(DurationUtil.Hour);
chain.HasPeriod.Should().Be.True();
chain.IsMoment.Should().Be.False();
chain.IsAnytime.Should().Be.False();
}
public void EndTest()
{
var now = ClockProxy.Clock.Now;
var chain = new TimePeriodChain();
chain.End.Should().Be(TimeSpec.MaxPeriodTime);
chain.Add(new TimeBlock(DurationUtil.Hour, now));
chain.End.Should().Be(now);
chain.Clear();
chain.End.Should().Be(TimeSpec.MaxPeriodTime);
}
public void StartTest()
{
var now = ClockProxy.Clock.Now;
var chain = new TimePeriodChain();
chain.Start.Should().Be(TimeSpec.MinPeriodTime);
chain.Add(new TimeBlock(now, DurationUtil.Hour));
chain.Start.Should().Be(now);
chain.Clear();
chain.Start.Should().Be(TimeSpec.MinPeriodTime);
}
public void HasStartTest()
{
TimePeriodChain timePeriods = new TimePeriodChain();
Assert.False(timePeriods.HasStart);
timePeriods.Add(new TimeBlock(TimeSpec.MinPeriodDate, Duration.Hour));
Assert.False(timePeriods.HasStart);
timePeriods.Clear();
timePeriods.Add(new TimeBlock(ClockProxy.Clock.Now, Duration.Hour));
Assert.True(timePeriods.HasStart);
} // HasStartTest
public void ClearTest()
{
TimePeriodChain timePeriods = new TimePeriodChain();
Assert.Equal(0, timePeriods.Count);
timePeriods.Clear();
Assert.Equal(0, timePeriods.Count);
SchoolDay schoolDay = new SchoolDay();
Assert.Equal(7, schoolDay.Count);
schoolDay.Clear();
Assert.Equal(0, schoolDay.Count);
} // ClearTest
public void IsAnyTimeTest() {
var now = ClockProxy.Clock.Now;
var chain = new TimePeriodChain();
chain.IsAnytime.Should().Be.True();
chain.Add(new TimeBlock(TimeSpec.MinPeriodTime, now));
chain.IsAnytime.Should().Be.False();
chain.Add(new TimeBlock(now, TimeSpec.MaxPeriodTime));
chain.IsAnytime.Should().Be.True();
}
public void ClearTest()
{
var timePeriods = new TimePeriodChain();
Assert.AreEqual(timePeriods.Count, 0);
timePeriods.Clear();
Assert.AreEqual(timePeriods.Count, 0);
SchoolDay schoolDay = new SchoolDay();
Assert.AreEqual(schoolDay.Count, 7);
schoolDay.Clear();
Assert.AreEqual(schoolDay.Count, 0);
}
public void HasEndTest()
{
DateTime now = ClockProxy.Clock.Now;
TimePeriodChain timePeriods = new TimePeriodChain();
Assert.False(timePeriods.HasEnd);
timePeriods.Add(new TimeBlock(Duration.Hour, TimeSpec.MaxPeriodDate));
Assert.False(timePeriods.HasEnd);
timePeriods.Clear();
timePeriods.Add(new TimeBlock(now, Duration.Hour));
Assert.True(timePeriods.HasEnd);
} // HasEndTest
public void CopyConstructorTest()
{
var schoolDay = new SchoolDay();
var copyChain = new TimePeriodChain(schoolDay);
copyChain.Count.Should().Be(schoolDay.Count);
copyChain.HasStart.Should().Be(schoolDay.HasStart);
copyChain.HasEnd.Should().Be(schoolDay.HasEnd);
copyChain.IsReadOnly.Should().Be(schoolDay.IsReadOnly);
copyChain.Start.Should().Be(schoolDay.Start);
copyChain.End.Should().Be(schoolDay.End);
copyChain.Duration.Should().Be(schoolDay.Duration);
}
public void IsAnyTimeTest()
{
var now = ClockProxy.Clock.Now;
var chain = new TimePeriodChain();
chain.IsAnytime.Should().Be.True();
chain.Add(new TimeBlock(TimeSpec.MinPeriodTime, now));
chain.IsAnytime.Should().Be.False();
chain.Add(new TimeBlock(now, TimeSpec.MaxPeriodTime));
chain.IsAnytime.Should().Be.True();
}
public void IsMomentTest()
{
DateTime now = ClockProxy.Clock.Now;
TimePeriodChain timePeriods = new TimePeriodChain();
Assert.False(timePeriods.IsMoment);
timePeriods.Add(new TimeBlock(now));
Assert.Equal(1, timePeriods.Count);
Assert.True(timePeriods.HasStart);
Assert.True(timePeriods.HasEnd);
Assert.True(timePeriods.IsMoment);
timePeriods.Add(new TimeBlock(now));
Assert.Equal(2, timePeriods.Count);
Assert.True(timePeriods.HasStart);
Assert.True(timePeriods.HasEnd);
Assert.True(timePeriods.IsMoment);
} // IsMomentTest
public void DurationTest() {
var chain = new TimePeriodChain();
chain.Duration.Should().Be(TimeSpec.MaxPeriodDuration);
chain.Add(new TimeBlock(ClockProxy.Clock.Now, DurationUtil.Hour));
chain.Duration.Should().Be(DurationUtil.Hour);
chain.HasPeriod.Should().Be.True();
chain.IsMoment.Should().Be.False();
chain.IsAnytime.Should().Be.False();
}
public void ContainsPeriodTest() {
var schoolDay = new SchoolDay();
var chain = new TimePeriodChain(schoolDay);
var timeRange = new TimeRange(schoolDay.Lesson1.Start, schoolDay.Lesson1.End);
chain.Contains(timeRange).Should().Be.False();
chain.ContainsPeriod(timeRange).Should().Be.True();
}
public void AddTimeRangeTest() {
var schoolDay = new SchoolDay();
var chain = new TimePeriodChain(schoolDay);
var range = new TimeRange(schoolDay.Lesson1.Start, schoolDay.Lesson1.End);
chain.Add(range);
chain.Last.Should().Be(range);
}
public void InsertTimeRangeTest() {
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
TimePeriodChain timePeriods = new TimePeriodChain(schoolDay);
TimeRange timeRange = new TimeRange(schoolDay.Lesson1.Start, schoolDay.Lesson1.End);
timePeriods.Add(timeRange);
Assert.AreEqual(timePeriods.Last, timeRange);
}
public void InsertReadOnlyTest() {
var timePeriods = new TimePeriodChain();
Assert.Throws<InvalidOperationException>(
() => timePeriods.Insert(0, new TimeRange(TimeSpec.MinPeriodTime, TimeSpec.MaxPeriodTime, true)));
}
public void CopyToTest() {
TimePeriodChain timePeriods = new TimePeriodChain();
ITimePeriod[] array1 = new ITimePeriod[0];
timePeriods.CopyTo(array1, 0);
SchoolDay schoolDay = new SchoolDay();
ITimePeriod[] array2 = new ITimePeriod[schoolDay.Count];
schoolDay.CopyTo(array2, 0);
Assert.AreEqual(array2[0], schoolDay.Lesson1);
Assert.AreEqual(array2[1], schoolDay.Break1);
Assert.AreEqual(array2[2], schoolDay.Lesson2);
Assert.AreEqual(array2[3], schoolDay.Break2);
Assert.AreEqual(array2[4], schoolDay.Lesson3);
Assert.AreEqual(array2[5], schoolDay.Break3);
Assert.AreEqual(array2[6], schoolDay.Lesson4);
ITimePeriod[] array3 = new ITimePeriod[schoolDay.Count + 3];
schoolDay.CopyTo(array3, 3);
Assert.AreEqual(array3[3], schoolDay.Lesson1);
Assert.AreEqual(array3[4], schoolDay.Break1);
Assert.AreEqual(array3[5], schoolDay.Lesson2);
Assert.AreEqual(array3[6], schoolDay.Break2);
Assert.AreEqual(array3[7], schoolDay.Lesson3);
Assert.AreEqual(array3[8], schoolDay.Break3);
Assert.AreEqual(array3[9], schoolDay.Lesson4);
}
public void ClearTest() {
var timePeriods = new TimePeriodChain();
Assert.AreEqual(timePeriods.Count, 0);
timePeriods.Clear();
Assert.AreEqual(timePeriods.Count, 0);
SchoolDay schoolDay = new SchoolDay();
Assert.AreEqual(schoolDay.Count, 7);
schoolDay.Clear();
Assert.AreEqual(schoolDay.Count, 0);
}
public void EndTest() {
var now = ClockProxy.Clock.Now;
var chain = new TimePeriodChain();
chain.End.Should().Be(TimeSpec.MaxPeriodTime);
chain.Add(new TimeBlock(DurationUtil.Hour, now));
chain.End.Should().Be(now);
chain.Clear();
chain.End.Should().Be(TimeSpec.MaxPeriodTime);
}
public void AddReadOnlyTest()
{
TimePeriodChain timePeriods = new TimePeriodChain();
timePeriods.Add(new TimeRange(TimeSpec.MinPeriodDate, TimeSpec.MaxPeriodDate, true));
} // AddReadOnlyTest
public void IsMomentTest() {
var now = ClockProxy.Clock.Now;
var chain = new TimePeriodChain();
chain.IsMoment.Should().Be.False();
chain.Add(new TimeBlock(now));
chain.Count.Should().Be(1);
chain.HasStart.Should().Be.True();
chain.HasEnd.Should().Be.True();
chain.HasPeriod.Should().Be.True();
chain.IsMoment.Should().Be.True();
chain.IsAnytime.Should().Be.False();
chain.Add(new TimeBlock(now.AddDays(1)));
chain.Count.Should().Be(2);
chain.HasStart.Should().Be.True();
chain.HasEnd.Should().Be.True();
chain.HasPeriod.Should().Be.True();
chain.IsMoment.Should().Be.True();
chain.IsAnytime.Should().Be.False();
chain.Add(new TimeBlock(now, TimeSpan.FromDays(1)));
chain.Count.Should().Be(3);
chain.HasStart.Should().Be.True();
chain.HasEnd.Should().Be.True();
chain.HasPeriod.Should().Be.True();
chain.IsMoment.Should().Be.False();
chain.IsAnytime.Should().Be.False();
}
public void StartTest() {
var now = ClockProxy.Clock.Now;
var chain = new TimePeriodChain();
chain.Start.Should().Be(TimeSpec.MinPeriodTime);
chain.Add(new TimeBlock(now, DurationUtil.Hour));
chain.Start.Should().Be(now);
chain.Clear();
chain.Start.Should().Be(TimeSpec.MinPeriodTime);
}
public void InsertReadOnlyTest()
{
TimePeriodChain timePeriods = new TimePeriodChain();
timePeriods.Insert(0, new TimeRange(TimeSpec.MinPeriodDate, TimeSpec.MaxPeriodDate, true));
} // InsertReadOnlyTest
