public void GetGapTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
TimePeriodCollection excludePeriods = new TimePeriodCollection();
TimeGapCalculator <TimeRange> gapCalculator = new TimeGapCalculator <TimeRange>();
excludePeriods.AddAll(schoolDay);
Assert.Equal(0, gapCalculator.GetGaps(excludePeriods).Count);
Assert.Equal(0, gapCalculator.GetGaps(excludePeriods, schoolDay).Count);
excludePeriods.Clear();
excludePeriods.Add(schoolDay.Lesson1);
excludePeriods.Add(schoolDay.Lesson2);
excludePeriods.Add(schoolDay.Lesson3);
excludePeriods.Add(schoolDay.Lesson4);
ITimePeriodCollection gaps2 = gapCalculator.GetGaps(excludePeriods);
Assert.Equal(3, gaps2.Count);
Assert.True(gaps2[0].IsSamePeriod(schoolDay.Break1));
Assert.True(gaps2[1].IsSamePeriod(schoolDay.Break2));
Assert.True(gaps2[2].IsSamePeriod(schoolDay.Break3));
TimeRange testRange3 = new TimeRange(schoolDay.Lesson1.Start, schoolDay.Lesson4.End);
ITimePeriodCollection gaps3 = gapCalculator.GetGaps(excludePeriods, testRange3);
Assert.Equal(3, gaps3.Count);
Assert.True(gaps3[0].IsSamePeriod(schoolDay.Break1));
Assert.True(gaps3[1].IsSamePeriod(schoolDay.Break2));
Assert.True(gaps3[2].IsSamePeriod(schoolDay.Break3));
TimeRange testRange4 = new TimeRange(schoolDay.Start.AddHours(-1), schoolDay.End.AddHours(1));
ITimePeriodCollection gaps4 = gapCalculator.GetGaps(excludePeriods, testRange4);
Assert.Equal(5, gaps4.Count);
Assert.True(gaps4[0].IsSamePeriod(new TimeRange(testRange4.Start, schoolDay.Start)));
Assert.True(gaps4[1].IsSamePeriod(schoolDay.Break1));
Assert.True(gaps4[2].IsSamePeriod(schoolDay.Break2));
Assert.True(gaps4[3].IsSamePeriod(schoolDay.Break3));
Assert.True(gaps4[4].IsSamePeriod(new TimeRange(testRange4.End, testRange3.End)));
excludePeriods.Clear();
excludePeriods.Add(schoolDay.Lesson1);
ITimePeriodCollection gaps8 = gapCalculator.GetGaps(excludePeriods, schoolDay.Lesson1);
Assert.Equal(0, gaps8.Count);
TimeRange testRange9 = new TimeRange(schoolDay.Lesson1.Start.Subtract(new TimeSpan(1)), schoolDay.Lesson1.End.Add(new TimeSpan(1)));
ITimePeriodCollection gaps9 = gapCalculator.GetGaps(excludePeriods, testRange9);
Assert.Equal(2, gaps9.Count);
Assert.Equal <TimeSpan>(gaps9[0].Duration, new TimeSpan(1));
Assert.Equal <TimeSpan>(gaps9[1].Duration, new TimeSpan(1));
} // GetGapsTest
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 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 ItemIndexTest()
{
SchoolDay schoolDay = new SchoolDay();
Assert.Equal(schoolDay[0], schoolDay.Lesson1);
Assert.Equal(schoolDay[1], schoolDay.Break1);
Assert.Equal(schoolDay[2], schoolDay.Lesson2);
Assert.Equal(schoolDay[3], schoolDay.Break2);
Assert.Equal(schoolDay[4], schoolDay.Lesson3);
Assert.Equal(schoolDay[5], schoolDay.Break3);
Assert.Equal(schoolDay[6], schoolDay.Lesson4);
} // ItemIndexTest
public void RemoveTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
TimePeriodCollection timePeriods = new TimePeriodCollection();
Assert.False(timePeriods.Contains(schoolDay.Lesson1));
timePeriods.Add(schoolDay.Lesson1);
Assert.True(timePeriods.Contains(schoolDay.Lesson1));
timePeriods.Remove(schoolDay.Lesson1);
Assert.False(timePeriods.Contains(schoolDay.Lesson1));
} // RemoveTest
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 StartMoveTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
TimePeriodCollection timePeriods = new TimePeriodCollection(schoolDay);
timePeriods.Start = now.AddHours(0);
Assert.Equal <DateTime>(timePeriods.Start, now);
timePeriods.Start = now.AddHours(1);
Assert.Equal <DateTime>(timePeriods.Start, now.AddHours(1));
timePeriods.Start = now.AddHours(-1);
Assert.Equal <DateTime>(timePeriods.Start, now.AddHours(-1));
} // StartMoveTest
public void AddAllTest()
{
SchoolDay schoolDay = new SchoolDay();
int count = schoolDay.Count;
TimeSpan duration = schoolDay.Duration;
DateTime start = schoolDay.Start;
schoolDay.AddAll(new SchoolDay());
Assert.Equal <int>(schoolDay.Count, count + count);
Assert.Equal <DateTime>(schoolDay.Start, start);
Assert.Equal <TimeSpan>(schoolDay.Duration, duration + duration);
} // AddAllTest
public void EndMoveTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
DateTime end = schoolDay.End;
schoolDay.End = end.AddHours(0);
Assert.Equal <DateTime>(schoolDay.End, end);
schoolDay.End = end.AddHours(1);
Assert.Equal <DateTime>(schoolDay.End, end.AddHours(1));
schoolDay.End = end.AddHours(-1);
Assert.Equal <DateTime>(schoolDay.End, end.AddHours(-1));
} // EndMoveTest
public void StartMoveTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
Assert.Equal <DateTime>(schoolDay.Start, now);
schoolDay.Start = now.AddHours(0);
Assert.Equal <DateTime>(schoolDay.Start, now);
schoolDay.Start = now.AddHours(1);
Assert.Equal <DateTime>(schoolDay.Start, now.AddHours(1));
schoolDay.Start = now.AddHours(-1);
Assert.Equal <DateTime>(schoolDay.Start, now.AddHours(-1));
} // StartMoveTest
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 AddAllTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
TimePeriodCollection timePeriods = new TimePeriodCollection();
Assert.Equal(0, timePeriods.Count);
timePeriods.AddAll(schoolDay);
Assert.Equal(timePeriods.Count, schoolDay.Count);
timePeriods.Clear();
Assert.Equal(0, timePeriods.Count);
} // AddAllTest
public void EndMoveTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
TimePeriodCollection timePeriods = new TimePeriodCollection(schoolDay);
DateTime end = schoolDay.End;
timePeriods.End = end.AddHours(0);
Assert.Equal <DateTime>(timePeriods.End, end);
timePeriods.End = end.AddHours(1);
Assert.Equal <DateTime>(timePeriods.End, end.AddHours(1));
timePeriods.End = end.AddHours(-1);
Assert.Equal <DateTime>(timePeriods.End, end.AddHours(-1));
} // EndMoveTest
public void ItemIndexTest()
{
TimePeriodCollection timePeriods = new TimePeriodCollection();
SchoolDay schoolDay = new SchoolDay();
timePeriods.AddAll(schoolDay);
Assert.Equal(timePeriods[0], schoolDay.Lesson1);
Assert.Equal(timePeriods[1], schoolDay.Break1);
Assert.Equal(timePeriods[2], schoolDay.Lesson2);
Assert.Equal(timePeriods[3], schoolDay.Break2);
Assert.Equal(timePeriods[4], schoolDay.Lesson3);
Assert.Equal(timePeriods[5], schoolDay.Break3);
Assert.Equal(timePeriods[6], schoolDay.Lesson4);
} // ItemIndexTest
public void AddTest()
{
SchoolDay schoolDay = new SchoolDay();
int count = schoolDay.Count;
DateTime end = schoolDay.End;
ShortBreak shortBreak = new ShortBreak(schoolDay.Start);
schoolDay.Add(shortBreak);
Assert.Equal <int>(schoolDay.Count, count + 1);
Assert.Equal(schoolDay.Last, shortBreak);
Assert.Equal <DateTime>(schoolDay.End, end.Add(shortBreak.Duration));
Assert.Equal <DateTime>(shortBreak.Start, end);
Assert.Equal(shortBreak.End, schoolDay.End);
Assert.Equal <TimeSpan>(shortBreak.Duration, ShortBreak.ShortBreakDuration);
} // AddTest
public void MoveTest()
{
SchoolDay schoolDay = new SchoolDay();
DateTime startDate = schoolDay.Start;
DateTime endDate = schoolDay.End;
TimeSpan startDuration = schoolDay.Duration;
TimeSpan duration = Duration.Hour;
schoolDay.Move(duration);
Assert.Equal <DateTime>(schoolDay.Start, startDate.Add(duration));
Assert.Equal <DateTime>(schoolDay.End, endDate.Add(duration));
Assert.Equal <TimeSpan>(schoolDay.Duration, startDuration);
} // MoveTest
public void CopyToTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
TimePeriodCollection timePeriods = new TimePeriodCollection(schoolDay);
ITimePeriod[] array = new ITimePeriod[schoolDay.Count];
timePeriods.CopyTo(array, 0);
Assert.Equal(array[0], schoolDay.Lesson1);
Assert.Equal(array[1], schoolDay.Break1);
Assert.Equal(array[2], schoolDay.Lesson2);
Assert.Equal(array[3], schoolDay.Break2);
Assert.Equal(array[4], schoolDay.Lesson3);
Assert.Equal(array[5], schoolDay.Break3);
Assert.Equal(array[6], schoolDay.Lesson4);
} // CopyToTest
public void IsSamePeriodTest()
{
SchoolDay schoolDay = new SchoolDay();
TimeRange manualRange = new TimeRange(schoolDay.Start, schoolDay.End);
Assert.True(schoolDay.IsSamePeriod(schoolDay));
Assert.True(schoolDay.IsSamePeriod(manualRange));
Assert.True(manualRange.IsSamePeriod(schoolDay));
Assert.False(schoolDay.IsSamePeriod(TimeBlock.Anytime));
Assert.False(manualRange.IsSamePeriod(TimeBlock.Anytime));
schoolDay.RemoveAt(0);
Assert.False(schoolDay.IsSamePeriod(manualRange));
Assert.False(manualRange.IsSamePeriod(schoolDay));
} // IsSamePeriodTest
public void IndexOfTest()
{
SchoolDay schoolDay = new SchoolDay();
Assert.Equal <int>(schoolDay.IndexOf(new TimeRange()), -1);
Assert.Equal <int>(schoolDay.IndexOf(new TimeBlock()), -1);
Assert.Equal(0, schoolDay.IndexOf(schoolDay.Lesson1));
Assert.Equal(1, schoolDay.IndexOf(schoolDay.Break1));
Assert.Equal(2, schoolDay.IndexOf(schoolDay.Lesson2));
Assert.Equal(3, schoolDay.IndexOf(schoolDay.Break2));
Assert.Equal(4, schoolDay.IndexOf(schoolDay.Lesson3));
Assert.Equal(5, schoolDay.IndexOf(schoolDay.Break3));
Assert.Equal(6, schoolDay.IndexOf(schoolDay.Lesson4));
schoolDay.Remove(schoolDay.Lesson1);
Assert.Equal <int>(schoolDay.IndexOf(schoolDay.Lesson1), -1);
} // IndexOfTest
public void IsSamePeriodTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
TimePeriodCollection timePeriods = new TimePeriodCollection(schoolDay);
Assert.True(timePeriods.IsSamePeriod(timePeriods));
Assert.True(timePeriods.IsSamePeriod(schoolDay));
Assert.True(schoolDay.IsSamePeriod(schoolDay));
Assert.True(schoolDay.IsSamePeriod(timePeriods));
Assert.False(timePeriods.IsSamePeriod(TimeBlock.Anytime));
Assert.False(schoolDay.IsSamePeriod(TimeBlock.Anytime));
timePeriods.RemoveAt(0);
Assert.False(timePeriods.IsSamePeriod(schoolDay));
} // IsSamePeriodTest
public void ContainsTest()
{
SchoolDay schoolDay = new SchoolDay();
Assert.False(schoolDay.Contains(new TimeRange()));
Assert.False(schoolDay.Contains(new TimeBlock()));
Assert.True(schoolDay.Contains(schoolDay.Lesson1));
Assert.True(schoolDay.Contains(schoolDay.Break1));
Assert.True(schoolDay.Contains(schoolDay.Lesson2));
Assert.True(schoolDay.Contains(schoolDay.Break2));
Assert.True(schoolDay.Contains(schoolDay.Lesson3));
Assert.True(schoolDay.Contains(schoolDay.Break3));
Assert.True(schoolDay.Contains(schoolDay.Lesson4));
schoolDay.Remove(schoolDay.Lesson1);
Assert.False(schoolDay.Contains(schoolDay.Lesson1));
} // ContainsTest
public void MoveTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
TimePeriodCollection timePeriods = new TimePeriodCollection(schoolDay);
DateTime startDate = schoolDay.Start;
DateTime endDate = schoolDay.End;
TimeSpan startDuration = timePeriods.Duration;
TimeSpan duration = Duration.Hour;
timePeriods.Move(duration);
Assert.Equal <DateTime>(timePeriods.Start, startDate.Add(duration));
Assert.Equal <DateTime>(timePeriods.End, endDate.Add(duration));
Assert.Equal <TimeSpan>(timePeriods.Duration, startDuration);
} // MoveTest
public void InsertTest()
{
SchoolDay schoolDay = new SchoolDay();
// first
int count = schoolDay.Count;
DateTime start = schoolDay.Start;
Lesson lesson1 = new Lesson(schoolDay.Start);
schoolDay.Insert(0, lesson1);
Assert.Equal <int>(schoolDay.Count, count + 1);
Assert.Equal(schoolDay[0], lesson1);
Assert.Equal(schoolDay.First, lesson1);
Assert.Equal(schoolDay.Start, start.Subtract(lesson1.Duration));
Assert.Equal(lesson1.Start, schoolDay.Start);
Assert.Equal <DateTime>(lesson1.End, start);
Assert.Equal <TimeSpan>(lesson1.Duration, Lesson.LessonDuration);
// inside
count = schoolDay.Count;
start = schoolDay.Start;
ShortBreak shortBreak1 = new ShortBreak(schoolDay.Start);
schoolDay.Insert(1, shortBreak1);
Assert.Equal <int>(schoolDay.Count, count + 1);
Assert.Equal(schoolDay[1], shortBreak1);
Assert.Equal(schoolDay.First, lesson1);
Assert.Equal <DateTime>(schoolDay.Start, start);
Assert.Equal(shortBreak1.Start, schoolDay.Start.Add(lesson1.Duration));
Assert.Equal <TimeSpan>(shortBreak1.Duration, ShortBreak.ShortBreakDuration);
// last
count = schoolDay.Count;
DateTime end = schoolDay.End;
ShortBreak shortBreak2 = new ShortBreak(schoolDay.Start);
schoolDay.Insert(schoolDay.Count, shortBreak2);
Assert.Equal <int>(schoolDay.Count, count + 1);
Assert.Equal(schoolDay[count], shortBreak2);
Assert.Equal(schoolDay.Last, shortBreak2);
Assert.Equal(schoolDay.End, shortBreak2.End);
Assert.Equal <DateTime>(shortBreak2.Start, end);
Assert.Equal <TimeSpan>(shortBreak2.Duration, ShortBreak.ShortBreakDuration);
} // InsertTest
public void RemoveAtTest()
{
SchoolDay schoolDay = new SchoolDay();
// first
int count = schoolDay.Count;
DateTime end = schoolDay.End;
ITimePeriod removeItem = schoolDay[0];
TimeSpan duration = schoolDay.Duration;
schoolDay.RemoveAt(0);
Assert.Equal <int>(schoolDay.Count, count - 1);
Assert.NotEqual(schoolDay[0], removeItem);
Assert.Equal <DateTime>(schoolDay.End, end);
Assert.Equal <TimeSpan>(schoolDay.Duration, duration.Subtract(removeItem.Duration));
// inside
count = schoolDay.Count;
duration = schoolDay.Duration;
DateTime start = schoolDay.Start;
ITimePeriod first = schoolDay.First;
ITimePeriod last = schoolDay.Last;
removeItem = schoolDay[1];
schoolDay.RemoveAt(1);
Assert.Equal <int>(schoolDay.Count, count - 1);
Assert.NotEqual(schoolDay[1], removeItem);
Assert.Equal(schoolDay.First, first);
Assert.Equal <DateTime>(schoolDay.Start, start);
Assert.Equal(schoolDay.Last, last);
Assert.Equal <TimeSpan>(schoolDay.Duration, duration.Subtract(removeItem.Duration));
// last
count = schoolDay.Count;
start = schoolDay.Start;
duration = schoolDay.Duration;
removeItem = schoolDay[schoolDay.Count - 1];
schoolDay.RemoveAt(schoolDay.Count - 1);
Assert.Equal <int>(schoolDay.Count, count - 1);
Assert.NotEqual(schoolDay[schoolDay.Count - 1], removeItem);
Assert.Equal <DateTime>(schoolDay.Start, start);
Assert.Equal <TimeSpan>(schoolDay.Duration, duration.Subtract(removeItem.Duration));
} // RemoveAtTest
public void GetRelationTest()
{
SchoolDay schoolDay = new SchoolDay();
TimeSpan offset = Duration.Second;
TimeRangePeriodRelationTestData testData = new TimeRangePeriodRelationTestData(schoolDay.Start, schoolDay.End, offset);
Assert.Equal(PeriodRelation.Before, schoolDay.GetRelation(testData.Before));
Assert.Equal(PeriodRelation.StartTouching, schoolDay.GetRelation(testData.StartTouching));
Assert.Equal(PeriodRelation.StartInside, schoolDay.GetRelation(testData.StartInside));
Assert.Equal(PeriodRelation.InsideStartTouching, schoolDay.GetRelation(testData.InsideStartTouching));
Assert.Equal(PeriodRelation.EnclosingStartTouching, schoolDay.GetRelation(testData.EnclosingStartTouching));
Assert.Equal(PeriodRelation.Enclosing, schoolDay.GetRelation(testData.Enclosing));
Assert.Equal(PeriodRelation.EnclosingEndTouching, schoolDay.GetRelation(testData.EnclosingEndTouching));
Assert.Equal(PeriodRelation.ExactMatch, schoolDay.GetRelation(testData.ExactMatch));
Assert.Equal(PeriodRelation.Inside, schoolDay.GetRelation(testData.Inside));
Assert.Equal(PeriodRelation.InsideEndTouching, schoolDay.GetRelation(testData.InsideEndTouching));
Assert.Equal(PeriodRelation.EndInside, schoolDay.GetRelation(testData.EndInside));
Assert.Equal(PeriodRelation.EndTouching, schoolDay.GetRelation(testData.EndTouching));
Assert.Equal(PeriodRelation.After, schoolDay.GetRelation(testData.After));
} // GetRelationTest
public void OverlapsWithTest()
{
SchoolDay schoolDay = new SchoolDay();
TimeSpan offset = Duration.Second;
TimeRangePeriodRelationTestData testData = new TimeRangePeriodRelationTestData(schoolDay.Start, schoolDay.End, offset);
Assert.False(schoolDay.OverlapsWith(testData.Before));
Assert.False(schoolDay.OverlapsWith(testData.StartTouching));
Assert.True(schoolDay.OverlapsWith(testData.StartInside));
Assert.True(schoolDay.OverlapsWith(testData.InsideStartTouching));
Assert.True(schoolDay.OverlapsWith(testData.EnclosingStartTouching));
Assert.True(schoolDay.OverlapsWith(testData.Enclosing));
Assert.True(schoolDay.OverlapsWith(testData.EnclosingEndTouching));
Assert.True(schoolDay.OverlapsWith(testData.ExactMatch));
Assert.True(schoolDay.OverlapsWith(testData.Inside));
Assert.True(schoolDay.OverlapsWith(testData.InsideEndTouching));
Assert.True(schoolDay.OverlapsWith(testData.EndInside));
Assert.False(schoolDay.OverlapsWith(testData.EndTouching));
Assert.False(schoolDay.OverlapsWith(testData.After));
} // OverlapsWithTest
public void RemoveAtTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
TimePeriodCollection timePeriods = new TimePeriodCollection(schoolDay);
// inside
Assert.Equal(timePeriods[2], schoolDay.Lesson2);
timePeriods.RemoveAt(2);
Assert.Equal(timePeriods[2], schoolDay.Break2);
// first
Assert.Equal(timePeriods[0], schoolDay.Lesson1);
timePeriods.RemoveAt(0);
Assert.Equal(timePeriods[0], schoolDay.Break1);
// last
Assert.Equal(timePeriods[timePeriods.Count - 1], schoolDay.Lesson4);
timePeriods.RemoveAt(timePeriods.Count - 1);
Assert.Equal(timePeriods[timePeriods.Count - 1], schoolDay.Break3);
} // RemoveAtTest
public void IndexOfTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay(now);
TimePeriodCollection timePeriods = new TimePeriodCollection();
Assert.Equal <int>(timePeriods.IndexOf(new TimeRange()), -1);
Assert.Equal <int>(timePeriods.IndexOf(new TimeBlock()), -1);
timePeriods.AddAll(schoolDay);
Assert.Equal(0, timePeriods.IndexOf(schoolDay.Lesson1));
Assert.Equal(1, timePeriods.IndexOf(schoolDay.Break1));
Assert.Equal(2, timePeriods.IndexOf(schoolDay.Lesson2));
Assert.Equal(3, timePeriods.IndexOf(schoolDay.Break2));
Assert.Equal(4, timePeriods.IndexOf(schoolDay.Lesson3));
Assert.Equal(5, timePeriods.IndexOf(schoolDay.Break3));
Assert.Equal(6, timePeriods.IndexOf(schoolDay.Lesson4));
timePeriods.Remove(schoolDay.Lesson1);
Assert.Equal <int>(timePeriods.IndexOf(schoolDay.Lesson1), -1);
} // IndexOfTest
public void LastTest()
{
SchoolDay schoolDay = new SchoolDay();
Assert.Equal(schoolDay.Last, schoolDay.Lesson4);
} // LastTest
public void FirstTest()
{
SchoolDay schoolDay = new SchoolDay();
Assert.Equal(schoolDay.First, schoolDay.Lesson1);
} // FirstTest
