public void SeparatingSessionsInTheSameTrackIntoDifferentTimslots_4Sessions3Tracks()
{
var sessions = new SessionsCollection();
sessions.Add(1, 1, Presenter.Create(1));
sessions.Add(2, 2, Presenter.Create(2));
sessions.Add(3, 1, Presenter.Create(3));
sessions.Add(4, 3, Presenter.Create(4));
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
rooms.Add(Room.Create(2, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1, 9.0));
timeslots.Add(Timeslot.Create(2, 10.25));
var engine = (null as IConferenceOptimizer).Create();
var assignments = engine.Process(sessions, rooms, timeslots);
assignments.WriteSchedule();
var s1TimeslotId = assignments.Where(a => a.SessionId == 1).Single().TimeslotId;
var s3TimeslotId = assignments.Where(a => a.SessionId == 3).Single().TimeslotId;
Assert.That(s1TimeslotId, Is.Not.EqualTo(s3TimeslotId), "Sessions with the same TopicId should not be in the same timeslot.");
}
public void AssigningAllSessions()
{
var sessions = new SessionsCollection();
sessions.Add(1, null, Presenter.Create(1));
sessions.Add(2, null, Presenter.Create(2));
sessions.Add(3, null, Presenter.Create(2));
sessions.Add(4, null, Presenter.Create(3));
sessions.Add(5, null, Presenter.Create(3));
sessions.Add(6, null, Presenter.Create(3));
sessions.Add(7, null, Presenter.Create(3));
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
rooms.Add(Room.Create(2, 10));
rooms.Add(Room.Create(3, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1));
timeslots.Add(Timeslot.Create(2));
timeslots.Add(Timeslot.Create(3));
timeslots.Add(Timeslot.Create(4));
timeslots.Add(Timeslot.Create(5));
var engine = (null as IConferenceOptimizer).Create();
var assignments = engine.Process(sessions, rooms, timeslots);
var assignmentsWithSessions = assignments.Where(a => a.SessionId.HasValue);
assignments.WriteSchedule();
Assert.That(assignmentsWithSessions.Count(), Is.EqualTo(sessions.Count()), "The wrong number of assignments were returned.");
}
public void ResultInTheSameNumberOfAssignments()
{
var sessions = new SessionsCollection();
sessions.Add(1, null, Presenter.Create(1));
sessions.Add(2, 1, Presenter.Create(2));
sessions.Add(3, null, Presenter.Create(3));
sessions.Add(4, 1, Presenter.Create(4));
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
rooms.Add(Room.Create(2, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1, 9.0));
timeslots.Add(Timeslot.Create(2, 10.25));
var solution = new Solution(sessions, rooms, timeslots);
while (solution.AssignmentsCompleted < sessions.Count())
{
solution.AssignSessionsWithOnlyOneOption();
solution.AssignMostConstrainedSession();
}
var s2 = solution.SwapAssignments();
Assert.AreEqual(solution.Assignments.Count(), s2.Assignments.Count());
}
public void PuttingSessionsInTheSameTrackIntoTheSameRoom_4Sessions1Track()
{
var sessions = new SessionsCollection();
sessions.Add(1, 1, Presenter.Create(1));
sessions.Add(2, 2, Presenter.Create(2));
sessions.Add(3, 1, Presenter.Create(3));
sessions.Add(4, 3, Presenter.Create(4));
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
rooms.Add(Room.Create(2, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1, 9.0));
timeslots.Add(Timeslot.Create(2, 10.25));
var engine = (null as IConferenceOptimizer).Create();
var assignments = engine.Process(sessions, rooms, timeslots);
assignments.WriteSchedule();
var s1RoomId = assignments.Where(a => a.SessionId == 1).Single().RoomId;
var s3RoomId = assignments.Where(a => a.SessionId == 3).Single().RoomId;
// Sessions with the same TopicId should be in the same room whenever possible
Assert.Equal(s1RoomId, s3RoomId);
}
public void NotAssigningASessionToARoomWhenItIsNotAvailableInTimesdlot2()
{
var engine = (null as IConferenceOptimizer).Create();
var sessions = new SessionsCollection();
sessions.Add(1, null, Presenter.Create(1));
sessions.Add(2, null, Presenter.Create(2));
sessions.Add(3, null, Presenter.Create(3));
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
rooms.Add(Room.Create(2, 10, 2));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1));
timeslots.Add(Timeslot.Create(2));
var assignments = engine.Process(sessions, rooms, timeslots);
var checkAssignment = assignments.Where(a => a.RoomId == 2 && a.TimeslotId == 2).SingleOrDefault();
assignments.WriteSchedule();
if (checkAssignment == null)
{
Assert.Null(checkAssignment);
}
else
{
// No session should have been assigned to room 2 during timeslot 2
Assert.Null(checkAssignment.SessionId);
}
}
public static void PlannedMaintenanceJobShouldFallWithinOneBusinessDay(this PlanMaintenanceJob command)
{
if (!Timeslot.Create(command.StartTime, command.EndTime).IsWithinOneDay())
{
throw new BusinessRuleViolationException("Start-time and end-time of a Maintenance Job must be within a 1 day.");
}
}
public void SeparatingSessionsInTheSameTrackIntoDifferentTimslots_4Sessions1Track()
{
var sessions = new SessionsCollection();
sessions.Add(1, null, Presenter.Create(1));
sessions.Add(2, 1, Presenter.Create(2));
sessions.Add(3, null, Presenter.Create(3));
sessions.Add(4, 1, Presenter.Create(4));
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
rooms.Add(Room.Create(2, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1, 9.0));
timeslots.Add(Timeslot.Create(2, 10.25));
var engine = (null as IConferenceOptimizer).Create();
var assignments = engine.Process(sessions, rooms, timeslots);
assignments.WriteSchedule();
var s2TimeslotId = assignments.Where(a => a.SessionId == 2).Single().TimeslotId;
var s4TimeslotId = assignments.Where(a => a.SessionId == 4).Single().TimeslotId;
// Sessions with the same TopicId should not be in the same timeslot
Assert.NotEqual(s2TimeslotId, s4TimeslotId);
}
public void ThrowingNoFeasibleSolutionIfSpeakerWouldHaveToBeInTwoPlacesAtOnce3SessionsFor1SpeakerWith2Timeslots()
{
var speaker1 = Presenter.Create(1);
var speaker2 = Presenter.Create(2);
var sessions = new SessionsCollection();
sessions.Add(1, null, speaker1);
sessions.Add(2, null, speaker1);
sessions.Add(3, null, speaker2);
sessions.Add(4, null, speaker1);
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
rooms.Add(Room.Create(2, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1));
timeslots.Add(Timeslot.Create(2));
var engine = (null as IConferenceOptimizer).Create();
Assert.Throws <Exceptions.NoFeasibleSolutionsException>(() => engine.Process(sessions, rooms, timeslots));
}
public void ThrowingDependencyExceptionIfCircularDependenciesExist()
{
var presenter1 = Presenter.Create(1, new int[] { 2 });
var sessions = new SessionsCollection();
var session1 = sessions.Add(1, 1, Presenter.Create(1));
var session2 = sessions.Add(2, 1, Presenter.Create(2));
var session3 = sessions.Add(3, 1, Presenter.Create(3));
session1.AddDependency(session2);
session2.AddDependency(session3);
session3.AddDependency(session1);
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
rooms.Add(Room.Create(2, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1));
timeslots.Add(Timeslot.Create(2));
var engine = (null as IConferenceOptimizer).Create();
Assert.Throws <Exceptions.DependencyException>(() => engine.Process(sessions, rooms, timeslots));
Assert.Throws <Exceptions.DependencyException>(() => engine.Process(sessions, rooms, timeslots));
}
public void ReturningTheOnlyPossibleAssignmentIfTheSecondSessionIsDependentOnTheFirst()
{
var engine = (null as IConferenceOptimizer).Create();
var sessions = new SessionsCollection();
var session1 = sessions.Add(1, null, Presenter.Create(1));
var session2 = sessions.Add(2, null, Presenter.Create(1));
session2.AddDependency(session1);
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1, 10));
timeslots.Add(Timeslot.Create(2, 11));
var assignments = engine.Process(sessions, rooms, timeslots);
var session2Assignment = assignments.Where(a => a.SessionId.Value == 2).Single();
assignments.WriteSchedule();
Assert.That(session2Assignment.TimeslotId, Is.EqualTo(2), "Session 2 must be assigned to timeslot 2 to satisfy the dependencies.");
}
private void Handle(MaintenanceJobFinished e)
{
MaintenanceJob job = Jobs.FirstOrDefault(j => j.Id == e.JobId);
Timeslot actualTimeslot = Timeslot.Create(e.StartTime, e.EndTime);
job.Finish(actualTimeslot, e.Notes);
}
public void ThrowingArgumentExceptionIfDuplicatePresenterIdsWithDifferentAvailabilityCountsExist()
{
var presenter1 = Presenter.Create(1, new int[] { 2 });
var presenter2 = Presenter.Create(2, new int[] { 2 });
var presenter3 = Presenter.Create(1);
var sessions = new SessionsCollection();
var session1 = sessions.Add(1, 1, presenter1);
var session2 = sessions.Add(2, 1, presenter2);
var session3 = sessions.Add(3, 1, presenter3);
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
rooms.Add(Room.Create(2, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1));
timeslots.Add(Timeslot.Create(2));
var engine = (null as IConferenceOptimizer).Create();
Assert.Throws <ArgumentException>(() => engine.Process(sessions, rooms, timeslots));
}
public void NotFailIfTwoUnnamedSessionsHaveTheSameTimeslotUnavailability()
{
// This test exposes a bug that existed in a version
// of the tool in early Oct 2018 where failing to add
// a name caused a collision in naming constraints
// if the same Timeslot is unavailable for multiple sessions
var engine = (null as IConferenceOptimizer).Create();
var sessions = new SessionsCollection();
sessions.Add(1, null, Presenter.Create(1, new int[] { 2 }));
sessions.Add(2, null, Presenter.Create(2, new int[] { 2 }));
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1));
timeslots.Add(Timeslot.Create(2));
timeslots.Add(Timeslot.Create(3));
var assignments = engine.Process(sessions, rooms, timeslots);
assignments.WriteSchedule();
}
public void Finish_Should_Finish_An_Existing_Job()
{
// arrange
MaintenanceJobBuilder maintenanceJobBuilder = new MaintenanceJobBuilder();
MaintenanceJob sut = maintenanceJobBuilder
.Build();
DateTime actualStartTime = maintenanceJobBuilder.StartTime.AddMinutes(30);
DateTime actualEndTime = maintenanceJobBuilder.EndTime.AddMinutes(15);
Timeslot actualTimeslot = Timeslot.Create(actualStartTime, actualEndTime);
string notes = $"Mechanic notes {maintenanceJobBuilder.JobId}";
// act
sut.Finish(actualTimeslot, notes);
// assert
Assert.Equal(maintenanceJobBuilder.JobId, sut.Id);
Assert.Equal(maintenanceJobBuilder.StartTime, sut.PlannedTimeslot.StartTime);
Assert.Equal(maintenanceJobBuilder.EndTime, sut.PlannedTimeslot.EndTime);
Assert.Equal(maintenanceJobBuilder.CustomerBuilder.Id, sut.Customer.Id);
Assert.Equal(maintenanceJobBuilder.CustomerBuilder.Name, sut.Customer.Name);
Assert.Equal(maintenanceJobBuilder.CustomerBuilder.TelephoneNumber, sut.Customer.TelephoneNumber);
Assert.Equal(maintenanceJobBuilder.VehicleBuilder.LicenseNumber, sut.Vehicle.Id);
Assert.Equal(maintenanceJobBuilder.VehicleBuilder.Brand, sut.Vehicle.Brand);
Assert.Equal(maintenanceJobBuilder.VehicleBuilder.Type, sut.Vehicle.Type);
Assert.Equal(maintenanceJobBuilder.VehicleBuilder.OwnerId, sut.Vehicle.OwnerId);
Assert.Equal(maintenanceJobBuilder.Description, sut.Description);
Assert.Equal(actualTimeslot, sut.ActualTimeslot);
Assert.Equal(notes, sut.Notes);
Assert.Equal("Completed", sut.Status);
}
public void ReturningTheCorrectAssignmentIfTwoSpeakersAreAvailableForTwoOfTheThreeSlots()
{
var engine = (null as IConferenceOptimizer).Create();
var sessions = new SessionsCollection();
sessions.Add(1, null, Presenter.Create(1, new int[] { 2 })); // Not available for slot 2
sessions.Add(2, null, Presenter.Create(2, new int[] { 2 })); // Not available for slot 2
sessions.Add(3, null, Presenter.Create(3)); // Available for all but must be assigned to slot 2
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1));
timeslots.Add(Timeslot.Create(2));
timeslots.Add(Timeslot.Create(3));
var assignments = engine.Process(sessions, rooms, timeslots);
var checkAssignment = assignments.Where(a => a.SessionId == 3).Single();
assignments.WriteSchedule();
// Session 3 should have been assigned to slot 2
Assert.Equal(2, checkAssignment.TimeslotId);
}
public void ReturningTheCorrectAssignmentIfOneSpeakerIsAvailableForOnlyOneSlot()
{
var engine = (null as IConferenceOptimizer).Create();
var sessions = new SessionsCollection();
sessions.Add(1, null, Presenter.Create(1));
sessions.Add(2, null, Presenter.Create(2, new int[] { 2, 3 })); // Only available for slot 1
sessions.Add(3, null, Presenter.Create(3));
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1));
timeslots.Add(Timeslot.Create(2));
timeslots.Add(Timeslot.Create(3));
var assignments = engine.Process(sessions, rooms, timeslots);
var checkAssignment = assignments.Where(a => a.SessionId == 2).Single();
assignments.WriteSchedule();
// Session 2 should have been assigned to slot 1
Assert.Equal(1, checkAssignment.TimeslotId);
}
public void ThrowingNoFeasibleSolutionIfAvailableTimeslotsForAMultiPresenterSessionDontIntersect()
{
// 2 presenters for one session where neither
// is available to present when the other is available
var presenter1 = Presenter.Create(1, new int[] { 2 });
var presenter2 = Presenter.Create(2, new int[] { 1 });
var sessions = new SessionsCollection();
sessions.Add(1, null, presenter1, presenter2);
var rooms = new List <Room>()
{
Room.Create(1, 10)
};
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1));
timeslots.Add(Timeslot.Create(2));
var engine = (null as IConferenceOptimizer).Create();
Assert.Throws <Exceptions.NoFeasibleSolutionsException>(() => engine.Process(sessions, rooms, timeslots));
}
public void FindingTheOnlyValidTimeslotForASessionWithChainedDependencies()
{
var engine = (null as IConferenceOptimizer).Create();
var sessions = new SessionsCollection();
var session1 = sessions.Add(1, null, Presenter.Create(1));
var session2 = sessions.Add(2, null, Presenter.Create(3));
var session3 = sessions.Add(3, null, Presenter.Create(1));
var session4 = sessions.Add(4, null, Presenter.Create(2));
var session5 = sessions.Add(5, null, Presenter.Create(2));
var session6 = sessions.Add(6, null, Presenter.Create(2));
session5.AddDependency(session6);
session4.AddDependency(session5);
var rooms = new List <Room>();
rooms.Add(Room.Create(1));
rooms.Add(Room.Create(2));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1, 8.5));
timeslots.Add(Timeslot.Create(2, 9.75));
timeslots.Add(Timeslot.Create(3, 11.0));
var assignments = engine.Process(sessions, rooms, timeslots);
assignments.WriteSchedule();
var testAssignment = assignments.Single(a => a.SessionId == 4);
Assert.That(testAssignment.TimeslotId, Is.EqualTo(3), "Session 4 must be in the 3rd timeslot");
}
public void ThrowADuplicateEntityExceptionIfATimeslotBuilderIsAddedWithAnIdAlreadyAddedAsATimeslot()
{
int id = Int32.MaxValue.GetRandom();
var target = new TimeslotCollectionBuilder()
.Add(Timeslot.Create(id));
Assert.Throws <DuplicateEntityException>(() => target.Add(new TimeslotBuilder(id)));
}
public void ReturnACollectionWithASingleTimeslotIfOneTimeslotAdded()
{
int id = Int32.MaxValue.GetRandom();
var actual = new TimeslotCollectionBuilder()
.Add(Timeslot.Create(id))
.Build();
Assert.Single(actual);
}
private void Handle(MaintenanceJobPlanned e)
{
MaintenanceJob job = new MaintenanceJob(e.JobId);
Customer customer = new Customer(e.CustomerInfo.Id, e.CustomerInfo.Name, e.CustomerInfo.TelephoneNumber);
LicenseNumber licenseNumber = LicenseNumber.Create(e.VehicleInfo.LicenseNumber);
Vehicle vehicle = new Vehicle(licenseNumber, e.VehicleInfo.Brand, e.VehicleInfo.Type, customer.Id);
Timeslot plannedTimeslot = Timeslot.Create(e.StartTime, e.EndTime);
job.Plan(plannedTimeslot, vehicle, customer, e.Description);
Jobs.Add(job);
}
public void ReturnACollectionWithTwoTimeslotsIfATimeslotAndATimeslotBuilderAreAdded()
{
int id1 = Int32.MaxValue.GetRandom();
int id2 = Int32.MaxValue.GetRandom();
var actual = new TimeslotCollectionBuilder()
.Add(Timeslot.Create(id1))
.Add(new TimeslotBuilder(id2))
.Build();
Assert.Equal(2, actual.Count());
}
private Teacher DaoToDomain(TeacherDao teacherDao)
{
var teacher = Teacher.Create(teacherDao.Id, teacherDao.Name);
foreach (var tsDao in teacherDao.AvailableTimeslots)
{
var timeslot = Timeslot.Create(tsDao.Id, tsDao.StartTime, tsDao.EndTime, teacher);
teacher.AvailableTimeslots.Add(timeslot);
}
return(teacher);
}
public void Creating_A_TimeSlot_With_A_StartTime_After_EndTime_Should_Throw_Exception()
{
// arrange
DateTime startTime = DateTime.Now;
DateTime endTime = startTime.AddHours(-2);
// act
var thrownException =
Assert.Throws <InvalidValueException>(() => Timeslot.Create(startTime, endTime));
// assert
Assert.Equal("The specified start-time may not be after the specified end-time.",
thrownException.Message);
}
public void ThrowingNoFeasibleSolutionsExceptionIfNoSessionsSupplied()
{
var sessions = new SessionsCollection();
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1));
var engine = (null as IConferenceOptimizer).Create();
var assignments = engine.Process(sessions, rooms, timeslots);
}
public void ThrowingArgumentNullExceptionIfRoomsIsNull()
{
var sessions = new SessionsCollection();
sessions.Add(1, 1, Presenter.Create(1));
IEnumerable <Room> rooms = null;
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1));
var engine = (null as IConferenceOptimizer).Create();
Assert.Throws <ArgumentNullException>(() => engine.Process(sessions, rooms, timeslots));
}
public void ThrowingArgumentExceptionIfNoRoomsSupplied()
{
var sessions = new SessionsCollection();
sessions.Add(1, 1);
var rooms = new List <Room>();
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1));
var engine = (null as IConferenceOptimizer).Create();
Assert.Throws <ArgumentException>(() => engine.Process(sessions, rooms, timeslots));
}
public void ThrowingArgumentNullExceptionIfSessionsIsNull()
{
IEnumerable <Session> sessions = null;
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1));
var engine = (null as IConferenceOptimizer).Create();
Assert.Throws <ArgumentNullException>(() => engine.Process(sessions, rooms, timeslots));
}
public void DistributingSessionsReasonablyAcrossTimeslotsWithNoDependencies()
{
var engine = (null as IConferenceOptimizer).Create();
var sessions = new SessionsCollection();
const int sessionCount = 12;
for (int i = 0; i < sessionCount; i++)
{
sessions.Add(i, i, Presenter.Create(i));
}
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
rooms.Add(Room.Create(2, 10));
rooms.Add(Room.Create(3, 10));
rooms.Add(Room.Create(4, 10));
rooms.Add(Room.Create(5, 10));
rooms.Add(Room.Create(6, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1, 9.0));
timeslots.Add(Timeslot.Create(2, 10.25));
timeslots.Add(Timeslot.Create(3, 11.5));
timeslots.Add(Timeslot.Create(4, 13.5));
timeslots.Add(Timeslot.Create(5, 14.75));
timeslots.Add(Timeslot.Create(6, 16.00));
var assignments = engine.Process(sessions, rooms, timeslots);
assignments.WriteSchedule();
bool hasSurplus = false;
for (int t = 0; t < timeslots.Count; t++)
{
hasSurplus = (hasSurplus || (assignments.Count(a => a.TimeslotId == t) > 2));
}
Assert.False(hasSurplus, "Sessions should be spread-out across timeslots");
}
public void ThrowingArgumentExceptionIfThereAreMoreSessionsThanSlotsAndRooms()
{
var engine = (null as IConferenceOptimizer).Create();
var sessions = new SessionsCollection();
sessions.Add(1, null, Presenter.Create(1));
sessions.Add(2, null, Presenter.Create(2));
var rooms = new List <Room>();
rooms.Add(Room.Create(1, 10));
var timeslots = new List <Timeslot>();
timeslots.Add(Timeslot.Create(1));
Assert.Throws <ArgumentException>(() => engine.Process(sessions, rooms, timeslots));
}
