/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
int hashCode = 41;
if (Copyrights != null)
{
hashCode = hashCode * 59 + Copyrights.GetHashCode();
}
if (JobId != null)
{
hashCode = hashCode * 59 + JobId.GetHashCode();
}
if (Status != null)
{
hashCode = hashCode * 59 + Status.GetHashCode();
}
if (WaitingInQueue != null)
{
hashCode = hashCode * 59 + WaitingInQueue.GetHashCode();
}
if (ProcessingTime != null)
{
hashCode = hashCode * 59 + ProcessingTime.GetHashCode();
}
if (Solution != null)
{
hashCode = hashCode * 59 + Solution.GetHashCode();
}
return(hashCode);
}
}
public static IEnumerable <object[]> DataTest()
{
var time = new ProcessingTime(1, 5, Distribution.Uniform);
yield return(new object[]
{
/*J1*/ Enumerable.Empty <Detail>(),
/*J2*/ Enumerable.Empty <Detail>(),
/*J12*/ Enumerable.Range(1, 4).Select(i => new LaboriousDetail(time, time, i)),
/*J21*/ Enumerable.Empty <LaboriousDetail>()
}); // should on second 0-1-2-3-4
yield return(new object[]
{
/*J1*/ Enumerable.Empty <Detail>(),
/*J2*/ Enumerable.Empty <Detail>(),
/*J12*/ Enumerable.Range(1, 1).Select(i => new LaboriousDetail(time, time, i)),
/*J21*/ Enumerable.Range(2, 2).Select(i => new LaboriousDetail(time, time, i))
}); // should be run without exceptions
yield return(new object[]
{
/*J1*/ Enumerable.Empty <Detail>(),
/*J2*/ Enumerable.Empty <Detail>(),
/*J12*/ Enumerable.Range(1, 2).Select(i => new LaboriousDetail(time, time, i)),
/*J21*/ Enumerable.Range(3, 1).Select(i => new LaboriousDetail(time, time, i))
}); // should be run without exceptions
}
public ProcessingTime LoadProcessingTime(int id)
{
ProcessingTime output = null;
var processEntity = _access.GetProcessingTimes().FirstOrDefault(t => t.Id == id);
if (processEntity != null)
{
output = new ProcessingTime
{
Id = processEntity.Id,
Every = processEntity.Every,
InitialDate = processEntity.InitialDate,
Replay = processEntity.Replay
};
}
return(output);
}
public void LoadTest()
{
CreateProcessingTimes();
ProcessingTimeFactory processingTimeFactory = new ProcessingTimeFactory(access);
ProcessingTime time1 = processingTimeFactory.LoadProcessingTime(1);
Assert.AreEqual(1, time1.Id);
Assert.AreEqual(Time1, time1.InitialDate);
Assert.AreEqual(Time1Reply, time1.Replay);
ProcessingTime time2 = processingTimeFactory.LoadProcessingTime(2);
Assert.AreEqual(2, time2.Id);
Assert.AreEqual(Time2, time2.InitialDate);
Assert.AreEqual(Time2Reply, time2.Replay);
}
public void CreateProcessingTimes()
{
ProcessingTime time1 = new ProcessingTime
{
Every = Time1Every,
InitialDate = Time1,
Replay = Time1Reply
};
access.CreateOrUpdate(time1);
ProcessingTime time2 = new ProcessingTime
{
Every = Time2Every,
InitialDate = Time2,
Replay = Time2Reply
};
access.CreateOrUpdate(time2);
}
/// <summary>
/// Returns true if Response instances are equal
/// </summary>
/// <param name="input">Instance of Response to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(Response input)
{
if (input == null)
{
return(false);
}
return
((
Copyrights == input.Copyrights ||
Copyrights != null &&
Copyrights.SequenceEqual(input.Copyrights)
) &&
(
JobId == input.JobId ||
(JobId != null &&
JobId.Equals(input.JobId))
) &&
(
Status == input.Status ||
(Status != null &&
Status.Equals(input.Status))
) &&
(
WaitingInQueue == input.WaitingInQueue ||
(WaitingInQueue != null &&
WaitingInQueue.Equals(input.WaitingInQueue))
) &&
(
ProcessingTime == input.ProcessingTime ||
(ProcessingTime != null &&
ProcessingTime.Equals(input.ProcessingTime))
) &&
(
Solution == input.Solution ||
(Solution != null &&
Solution.Equals(input.Solution))
));
}
