public void T001_ScheduleItem_Constructors()
{
//Basic constructor
ScheduleItem theBasicItem = new ScheduleItem(itemName);
Assert.AreEqual<string>(itemName, theBasicItem.ItemName);
Assert.AreEqual<int>(0, theBasicItem.Duration);
//Detailed constructor (start/end hours and minutes)
ScheduleItem theDetailItem1 = new ScheduleItem(itemName, startHour, startMinute, endHour, endMinute);
Assert.AreEqual<string>(itemName, theDetailItem1.ItemName);
Assert.AreEqual<TimeHHMM>(startTime, theDetailItem1.StartTime);
Assert.AreEqual<TimeHHMM>(endTime, theDetailItem1.EndTime);
Assert.AreEqual<int>(duration, theDetailItem1.Duration);
//Detailed constructor (start/end time objects)
ScheduleItem theDetailItem2 = new ScheduleItem(itemName, startTime, endTime);
Assert.AreEqual<string>(itemName, theDetailItem2.ItemName);
Assert.AreEqual<TimeHHMM>(startTime, theDetailItem2.StartTime);
Assert.AreEqual<TimeHHMM>(endTime, theDetailItem2.EndTime);
Assert.AreEqual<int>(duration, theDetailItem2.Duration);
//Detailed constructor (start hour/minute and duration)
ScheduleItem theDetailItem3 = new ScheduleItem(itemName, startHour, startMinute, duration);
Assert.AreEqual<string>(itemName, theDetailItem3.ItemName);
Assert.AreEqual<TimeHHMM>(startTime, theDetailItem3.StartTime);
Assert.AreEqual<TimeHHMM>(endTime, theDetailItem3.EndTime);
Assert.AreEqual<int>(duration, theDetailItem3.Duration);
//Detailed constructor (start time and duration)
ScheduleItem theDetailItem4 = new ScheduleItem(itemName, startTime, duration);
Assert.AreEqual<string>(itemName, theDetailItem4.ItemName);
Assert.AreEqual<TimeHHMM>(startTime, theDetailItem4.StartTime);
Assert.AreEqual<TimeHHMM>(endTime, theDetailItem4.EndTime);
Assert.AreEqual<int>(duration, theDetailItem4.Duration);
}
public bool Equals(ScheduleItem rhs)
{
//Check for null
if (null == (object)rhs)
{
return false;
}
//Equal if name, startTime, and endTime are equal
return ((ItemName == rhs.ItemName) && (StartTime == rhs.StartTime) && (EndTime == rhs.EndTime));
}
/**
*<summary>
* Checks if two ScheduleItems conflict
*</summary>
*/
public bool ConflictsWith(ScheduleItem item2)
{
//Check for null
if(null == (object) item2)
{
return false;
}
//Check that start time
if(item2.StartTime >= EndTime)
{
return false;
}
if(item2.StartTime >= StartTime)
{
return true;
}
//Check that end time out of range
if(item2.EndTime <= StartTime)
{
return false;
}
if(item2.EndTime <= EndTime)
{
return true;
}
return false;
}
public void T002_Student_AddClass()
{
/** Method Locals */
//Miscellaneous
bool result = false;
//Student object
Student nominalTestStudent = new Student("John", "Doe");
Student failTestStudent = new Student("Jane", "Doe");
Student scheduleConflictStudent = new Student("Steve", "Doe");
Student nameConflictStudent = new Student("Sally", "Doe");
//Class names
String[] classNames =
{
"Homeroom",
"Reading",
"Math",
"Social Studies",
"Recess"
};
//Class start times Tuples
Tuple<int, int>[] startTimes =
{
new Tuple<int, int>( 8, 0),
new Tuple<int, int>( 9, 0),
new Tuple<int, int>( 9, 55),
new Tuple<int, int>(10, 40),
new Tuple<int, int>(11, 30)
};
//Class start time TimeHHMM
TimeHHMM[] classStartTimes =
{
new TimeHHMM(startTimes[0].Item1, startTimes[0].Item2),
new TimeHHMM(startTimes[1].Item1, startTimes[1].Item2),
new TimeHHMM(startTimes[2].Item1, startTimes[2].Item2),
new TimeHHMM(startTimes[3].Item1, startTimes[3].Item2),
new TimeHHMM(startTimes[4].Item1, startTimes[4].Item2)
};
//Class end times Tuples
Tuple<int, int>[] endTimes =
{
new Tuple<int, int>( 8, 50),
new Tuple<int, int>( 9, 45),
new Tuple<int, int>(10, 30),
new Tuple<int, int>(11, 30),
new Tuple<int, int>(12, 15)
};
//Class end time TimeHHMM
TimeHHMM[] classEndTimes =
{
new TimeHHMM(endTimes[0].Item1, endTimes[0].Item2),
new TimeHHMM(endTimes[1].Item1, endTimes[1].Item2),
new TimeHHMM(endTimes[2].Item1, endTimes[2].Item2),
new TimeHHMM(endTimes[3].Item1, endTimes[3].Item2),
new TimeHHMM(endTimes[4].Item1, endTimes[4].Item2)
};
/** Nominal AddClass() Scenarios */
result = nominalTestStudent.AddClass(classNames[0], classStartTimes[0], classEndTimes[0]);
Assert.IsTrue(result);
result = nominalTestStudent.AddClass(classNames[1], startTimes[1].Item1, startTimes[1].Item2, 50);
Assert.IsTrue(result);
result = nominalTestStudent.AddClass(classNames[2], startTimes[2].Item1, startTimes[2].Item2, endTimes[2].Item1, endTimes[2].Item2);
Assert.IsTrue(result);
result = nominalTestStudent.AddClass(classNames[3], classStartTimes[3], 50);
Assert.IsTrue(result);
result = nominalTestStudent.AddClass(new ScheduleItem(classNames[4], classStartTimes[4], classEndTimes[4]));
Assert.IsTrue(result);
/** Failure AddClass() Scenarios */
result = failTestStudent.AddClass("", classStartTimes[0], classEndTimes[0]);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[0], null, classEndTimes[0]);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[0], classStartTimes[0], null);
Assert.IsFalse(result);
result = failTestStudent.AddClass("", startTimes[1].Item1, startTimes[1].Item2, 50);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[1], -1, startTimes[1].Item2, 50);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[1], 24, startTimes[1].Item2, 50);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[1], startTimes[1].Item1, -1, 50);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[1], startTimes[1].Item1, 60, 50);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[1], startTimes[1].Item1, startTimes[1].Item2, 0);
Assert.IsFalse(result);
result = failTestStudent.AddClass("", startTimes[2].Item1, startTimes[2].Item2, endTimes[2].Item1, endTimes[2].Item2);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[2], -1, startTimes[2].Item2, endTimes[2].Item1, endTimes[2].Item2);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[2], 24, startTimes[2].Item2, endTimes[2].Item1, endTimes[2].Item2);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[2], startTimes[2].Item1, -1, endTimes[2].Item1, endTimes[2].Item2);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[2], startTimes[2].Item1, 60, endTimes[2].Item1, endTimes[2].Item2);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[2], startTimes[2].Item1, startTimes[2].Item2, -1, endTimes[2].Item2);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[2], startTimes[2].Item1, startTimes[2].Item2, 24, endTimes[2].Item2);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[2], startTimes[2].Item1, startTimes[2].Item2, endTimes[2].Item1, -1);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[2], startTimes[2].Item1, startTimes[2].Item2, endTimes[2].Item1, 60);
Assert.IsFalse(result);
result = failTestStudent.AddClass("", classStartTimes[3], 50);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[3], null, 50);
Assert.IsFalse(result);
result = failTestStudent.AddClass(classNames[3], classStartTimes[3], 0);
Assert.IsFalse(result);
result = failTestStudent.AddClass(null);
Assert.IsFalse(result);
/** Schedule conflict failure */
TimeHHMM overlappingStart = classStartTimes[0] - 15;
TimeHHMM overlappingEnd = classEndTimes[0] - 15;
result = scheduleConflictStudent.AddClass(classNames[0], classStartTimes[0], classEndTimes[0]); //Add first class
Assert.IsTrue(result);
//Overlap start of class by 15m
result = scheduleConflictStudent.AddClass("WillFailClass", overlappingStart, classEndTimes[0]);
Assert.IsFalse(result);
result = scheduleConflictStudent.AddClass("WillFailClass", overlappingStart.Hour, overlappingStart.Minute, 30);
Assert.IsFalse(result);
result = scheduleConflictStudent.AddClass("WillFailClass", overlappingStart.Hour, overlappingStart.Minute, endTimes[0].Item1, endTimes[0].Item2);
Assert.IsFalse(result);
result = scheduleConflictStudent.AddClass("WillFailClass", overlappingStart, 30);
Assert.IsFalse(result);
result = scheduleConflictStudent.AddClass(new ScheduleItem("WillFailClass", overlappingStart, 30));
Assert.IsFalse(result);
//Overlap end of class by 15m
result = scheduleConflictStudent.AddClass("WillFailClass", overlappingEnd, classEndTimes[0]);
Assert.IsFalse(result);
result = scheduleConflictStudent.AddClass("WillFailClass", overlappingEnd.Hour, overlappingEnd.Minute, 15);
Assert.IsFalse(result);
result = scheduleConflictStudent.AddClass("WillFailClass", overlappingEnd.Hour, overlappingEnd.Minute, endTimes[0].Item1, endTimes[0].Item2);
Assert.IsFalse(result);
result = scheduleConflictStudent.AddClass("WillFailClass", overlappingEnd, 15);
Assert.IsFalse(result);
result = scheduleConflictStudent.AddClass(new ScheduleItem("WillFailClass", overlappingEnd, 15));
Assert.IsFalse(result);
/** Name conflict failure */
ScheduleItem duplicateClass = new ScheduleItem(classNames[0], classEndTimes[0] + 30, 30);
//Add valid class to schedule
result = nameConflictStudent.AddClass(classNames[0], classStartTimes[0], classEndTimes[0]);
Assert.IsTrue(result);
//Try to add duplicate class (same name, different time)
result = nameConflictStudent.AddClass(duplicateClass);
Assert.IsFalse(result);
}
public void T004_Student_Reschedule()
{
bool result = false;
//Classes for test
ScheduleItem class1 = new ScheduleItem("Class1", new TimeHHMM(8, 30), 30);
ScheduleItem class2 = new ScheduleItem("Class2", new TimeHHMM(9, 30), 30);
ScheduleItem class2moved = new ScheduleItem("Class2", new TimeHHMM(12, 30), 30);
//Student for test
Student testStudent = new Student("Jane", "Doe");
//Build basic, valid schedule
result = testStudent.AddClass(class1);
Assert.IsTrue(result);
result = testStudent.AddClass(class2);
Assert.IsTrue(result);
Assert.AreEqual<int>(2, testStudent.StudentSchedule.Count);
/** Nominal reschedule */
result = testStudent.Reschedule(class2.ItemName, new TimeHHMM(12, 30));
Assert.IsTrue(result);
Assert.AreEqual<int>(2, testStudent.StudentSchedule.Count); //Still only 2 classes in schedule
/** Conflict reschedule */
result = testStudent.Reschedule(class2.ItemName, new TimeHHMM(8, 45));
Assert.IsFalse(result);
result = testStudent.GetClass(class1.ItemName) == class1;
Assert.IsTrue(result); //Class1 hasn't moved
result = testStudent.GetClass(class2moved.ItemName) == class2moved;
Assert.IsTrue(result); //Class2 is still in modified location
}
public void T003_Student_GetClass()
{
bool result = false;
/** Classes for test */
ScheduleItem class1 = new ScheduleItem("Class1", new TimeHHMM(8, 30), 30);
ScheduleItem class2 = new ScheduleItem("Class2", new TimeHHMM(9, 30), 30);
ScheduleItem foundClass;
/** Student for test */
Student testStudent = new Student("Jane", "Doe");
//Build basic, valid schedule
result = testStudent.AddClass(class1);
Assert.IsTrue(result);
result = testStudent.AddClass(class2);
Assert.IsTrue(result);
Assert.AreEqual<int>(2, testStudent.StudentSchedule.Count);
//Nominal GetClass
foundClass = testStudent.GetClass(class1.ItemName);
Assert.AreEqual<ScheduleItem>(class1, foundClass);
foundClass = testStudent.GetClass(class2.ItemName);
Assert.AreEqual<ScheduleItem>(class2, foundClass);
//Failed GetClass
foundClass = testStudent.GetClass("Class3");
Assert.AreEqual<object>(null, (object)foundClass);
}
public void T002_ScheduleItem_ConflictsWith()
{
bool result = false;
//New TimeHHMMs for Test
TimeHHMM time1 = new TimeHHMM(8, 30);
TimeHHMM time2 = new TimeHHMM(8, 45);
TimeHHMM time3 = new TimeHHMM(9, 0);
//ScheduleItems for Test
ScheduleItem item1 = new ScheduleItem("Item1", time1, 30);
ScheduleItem item2 = new ScheduleItem("Item2", time2, 30);
ScheduleItem item3 = new ScheduleItem("Item3", time3, 30);
//No Conflict
result = item1.ConflictsWith(item3);
Assert.IsFalse(result);
result = item1.ConflictsWith(null);
Assert.IsFalse(result);
//Conflict
result = item1.ConflictsWith(item2);
Assert.IsTrue(result);
}
public void T005_ScheduleItem_Reschedule()
{
bool result = false;
//TimeHHMMs for Test
TimeHHMM startTime = new TimeHHMM(8, 30);
TimeHHMM endTime = new TimeHHMM(9, 0);
TimeHHMM newTime = new TimeHHMM(9, 30);
//Nominal Test
ScheduleItem nominalItem = new ScheduleItem("Nominal Item", startTime, endTime);
result = nominalItem.Reschedule(newTime);
Assert.IsTrue(result);
Assert.AreEqual<TimeHHMM>(newTime, nominalItem.StartTime); //New start time
Assert.AreNotEqual<TimeHHMM>(endTime, nominalItem.EndTime); //New end time
Assert.AreEqual<int>((int) (endTime - startTime).TotalMinutes, nominalItem.Duration); //Same duration
//Failed test
ScheduleItem failureItem = new ScheduleItem("Failure Item", new TimeHHMM(11, 0), 45);
result = failureItem.Reschedule(null);
Assert.IsFalse(result);
}
/**
*<summary>
*With Name, Start hour/minute, and End hour/minute
*</summary>
*/
public bool AddClass(string className, int startHour, int startMinute, int endHour, int endMinute)
{
//Validate className (non-empty String)
if ("" == className)
{
return false;
}
//Validate startHour (0-23)
if ((0 > startHour) || (23 < startHour))
{
return false;
}
//Validate startMinute (0-59)
if ((0 > startMinute) || (59 < startMinute))
{
return false;
}
//Validate endHour (0-23)
if ((0 > endHour) || (23 < endHour))
{
return false;
}
//Validate endMinute (0-59)
if ((0 > endMinute) || (59 < endMinute))
{
return false;
}
//Create the ScheduleItem
ScheduleItem newClass = new ScheduleItem(className, new TimeHHMM(startHour, startMinute), new TimeHHMM(endHour, endMinute));
if (scheduleConflict(newClass))
{
return false;
}
//Check that new class isn't same name as any existing
if (nameConflict(newClass))
{
return false;
}
//Add class to schedule
studentSchedule.Add(newClass);
return true;
}
public void T004_ScheduleItem_ConflictsWithEnd()
{
bool result = false;
//New TimeHHMMs for Test
TimeHHMM time1 = new TimeHHMM(8, 30);
TimeHHMM time2 = new TimeHHMM(8, 45);
TimeHHMM time3 = new TimeHHMM(9, 0);
//ScheduleItems for Test
ScheduleItem item = new ScheduleItem("Item", time1, 30);
//No Conflict
result = item.ConflictsWithEnd(time1);
Assert.IsFalse(result);
//Conflict
result = item.ConflictsWithEnd(time2);
Assert.IsTrue(result);
result = item.ConflictsWithEnd(time3);
Assert.IsTrue(result);
}
/**
*<summary>
*Schedule conflict helper (ScheduleItems conflict with ScheduleItems)
*</summary>
*/
private bool scheduleConflict(ScheduleItem newClass)
{
return (null != (object)studentSchedule.Find(x => x.ConflictsWith(newClass)));
}
/**
*<summary>
*Name conflict helper
*</summary>
*/
private bool nameConflict(ScheduleItem newClass)
{
return (null != (object)studentSchedule.Find(x => x.ItemName.Equals(newClass.ItemName)));
}
/**
*<summary>
*With ScheduleItem
*</summary>
*/
public bool AddClass(ScheduleItem newClass)
{
//Validate newClass
if(null == (object)newClass)
{
return false;
}
//Check that new class doesnt conflict with any existing
if(scheduleConflict(newClass))
{
return false;
}
//Check that new class isn't same name as any existing
if(nameConflict(newClass))
{
return false;
}
//Add class to schedule
studentSchedule.Add(newClass);
return true;
}
/**
*<summary>
*With Name, Start TimeHHMM, and Duration
*</summary>
*/
public bool AddClass(string className, TimeHHMM startTime, int minutesDuration)
{
//Validate className
if ("" == className)
{
return false;
}
//Validate startTime
if (null == (object)startTime)
{
return false;
}
//Validate minutesDuration
if (minutesDuration <= 0)
{
return false;
}
//Check that new class doesn't conflict with any existing
ScheduleItem newClass = new ScheduleItem(className, startTime, minutesDuration);
if (scheduleConflict(newClass))
{
return false;
}
//Check that new class isn't same name as any existing
if (nameConflict(newClass))
{
return false;
}
//Add class to schedule
studentSchedule.Add(newClass);
return true;
}
/**
*<summary>
*With Name, Start hour/minute, and Duration
*</summary>
*/
public bool AddClass(string className, int startHour, int startMinute, int minutesDuration)
{
//Validate className
if ("" == className)
{
return false;
}
//Validate startHour (0-23)
if ((0 > startHour) || (23 < startHour))
{
return false;
}
//Validate startMinute (0-59)
if ((0 > startMinute) || (59 < startMinute))
{
return false;
}
//Validate minutesDuration
if (minutesDuration <= 0)
{
return false;
}
//Check that new class doesn't conflict with any existing
ScheduleItem newClass = new ScheduleItem(className, startHour, startMinute, minutesDuration);
if (scheduleConflict(newClass))
{
return false;
}
//Check that new class isn't same name as any existing
if (nameConflict(newClass))
{
return false;
}
//Add class to schedule
studentSchedule.Add(newClass);
return true;
}
