public void ToStringIsCorrectForNonCancelledResult()
{
var result = new ContinuousResult(value: 2.5, runtime: TimeSpan.FromMilliseconds(42));
Assert.Equal(
FormattableString.Invariant($"Runtime: {TimeSpan.FromMilliseconds(42):G}, Value: 2.5"),
result.ToString());
}
public void GetMetricRepresentationReturnsValue()
{
var result = new ContinuousResult(100, TimeSpan.Zero);
Assert.Equal(
100,
SortByValueTest.ascendingSorter.GetMetricRepresentation(result));
}
public void ToStringIsCorrectForCancelledResult()
{
var runtime = TimeSpan.FromMilliseconds(42);
var result = ContinuousResult.CreateCancelledResult(runtime);
Assert.Equal(
FormattableString.Invariant($"Cancelled after {TimeSpan.FromMilliseconds(42):G} with value set to NaN"),
result.ToString());
}
public void GetMetricRepresentationReturnsValue(bool sortAscending)
{
var sorter = new SortByValue <TestInstance>(sortAscending);
var result = new ContinuousResult(100, TimeSpan.Zero);
Assert.Equal(
100,
sorter.GetMetricRepresentation(result));
}
public void TryToGetResultFromStringArrayWorksForContinuousResults()
{
var continuousResult = new ContinuousResult(0.5, TimeSpan.FromSeconds(30));
var targetAlgorithmFactory =
new DummyTargetAlgorithmFactory <DummyTargetAlgorithm <TestInstance, ContinuousResult>, TestInstance, ContinuousResult>() as
ITargetAlgorithmFactory <DummyTargetAlgorithm <TestInstance, ContinuousResult>, TestInstance, ContinuousResult>;
targetAlgorithmFactory.TryToGetResultFromStringArray(continuousResult.ToStringArray(), out var result).ShouldBeTrue();
result.TargetAlgorithmStatus.ShouldBe(continuousResult.TargetAlgorithmStatus);
result.IsCancelled.ShouldBe(continuousResult.IsCancelled);
result.Runtime.ShouldBe(continuousResult.Runtime);
result.Value.ShouldBe(continuousResult.Value);
}
public void RacingRemovesKilledGenomesFromQueue()
{
var participants = this.CreateGenomesDescendingByAge(2, 0).ToList();
var instances = this._instances.Take(2).ToList();
var queue = new SimplePriorityQueue <GenomeTournamentKey, double>();
// always return second genome as target to kill by racing.
var evaluatorMock = new Mock <IRunEvaluator <TestInstance, ContinuousResult> >();
evaluatorMock.Setup(
e => e.GetGenomesThatCanBeCancelledByRacing(
It.IsAny <IReadOnlyList <ImmutableGenomeStats <TestInstance, ContinuousResult> > >(),
It.IsAny <int>()))
.Returns(new[] { participants[1] });
var manager = new MiniTournamentManager <TestInstance, ContinuousResult>(
participants,
instances,
0,
0,
evaluatorMock.Object,
true,
1);
this.RequeueAllEvaluations(manager);
manager.StartSynchronizingQueue(queue);
queue.Count.ShouldBe(2);
// start an instance
var winnerGenome = new GenomeTournamentKey(participants[0], 0);
manager.TryGetNextInstanceAndUpdateGenomePriority(winnerGenome, out var instance).ShouldBeTrue();
// send a result
var result = new ContinuousResult(42, TimeSpan.Zero);
var genomeInstancePair = new GenomeInstancePair <TestInstance>(winnerGenome.Genome, instance);
manager.UpdateResult(genomeInstancePair, result);
// second genome should have been killed by racing + removed from queue
queue.Count.ShouldBe(1);
queue.First.ShouldBe(winnerGenome);
}
/// <summary>
/// Creates genome stats for testing.
/// </summary>
/// <param name="genome">The genome.</param>
/// <param name="instances">The instances.</param>
/// <param name="indexToResult">A function to provide a result by instance index.</param>
/// <param name="numInstancesToUse">The number of instances to use from the list.</param>
/// <returns>The genome stats.</returns>
private GenomeStats <TestInstance, ContinuousResult> CreateStats(
ImmutableGenome genome,
IReadOnlyList <TestInstance> instances,
Func <int, double> indexToResult,
int?numInstancesToUse = null)
{
if (numInstancesToUse == null || numInstancesToUse > instances.Count)
{
numInstancesToUse = instances.Count;
}
var stats = new GenomeStats <TestInstance, ContinuousResult>(genome, Enumerable.Empty <TestInstance>(), instances);
for (var i = 0; i < numInstancesToUse; i++)
{
var result = new ContinuousResult(indexToResult(i), TimeSpan.Zero);
stats.FinishInstance(instances[i], result);
}
return(stats);
}
public void IsCancelledIsFalseByDefault()
{
var result = new ContinuousResult(value: 42, runtime: TimeSpan.FromMilliseconds(0));
Assert.False(result.IsCancelled, "Result is supposedly cancelled directly after construction.");
}
public void RuntimeIsSetCorrectly()
{
var result = new ContinuousResult(value: 0, runtime: TimeSpan.FromMilliseconds(42));
Assert.Equal(42, result.Runtime.TotalMilliseconds);
}
public void ValueIsSetCorrectly()
{
var result = new ContinuousResult(value: 42, runtime: TimeSpan.FromMilliseconds(0));
Assert.Equal(42, result.Value);
}
/// <summary>
/// Checks, if the result has a valid result value.
/// </summary>
/// <param name="result">The result.</param>
/// <returns>True, if the result has a valid result value.</returns>
private static bool HasValidResultValue(ContinuousResult result)
{
return(!result.IsCancelled && !double.IsNaN(result.Value) && !double.IsInfinity(result.Value));
}
/// <inheritdoc />
public double GetMetricRepresentation(ContinuousResult result)
{
return(result.Value);
}
