public void MapDrivers_ThreeDrivers_FromValidData(DriverMapper mapper,
DriverCodeGenerator driverCodeGenerator,
string team, string status)
{
var code1 = driverCodeGenerator.Generate().Code;
var code2 = driverCodeGenerator.Generate().Code;
var code3 = driverCodeGenerator.Generate().Code;
var driverDtoCollection = new List <DriverDto>
{
new DriverDto(code1, "John", "Read"),
new DriverDto(code2, "Sarah", "Jones"),
new DriverDto(code3, "Paul", "Kim")
};
var raceResultDto = new List <RaceResultDto>
{
new RaceResultDto(code1, 1, team, status),
new RaceResultDto(code2, 2, team, status),
new RaceResultDto(code3, 3, team, status),
};
var drivers = mapper.ToDriver(driverDtoCollection, raceResultDto);
Assert.NotNull(drivers);
Assert.Equal(3, drivers.Count);
}
public void Duplicate_ShouldThrowArgException_WhenAddingDrivers(DriverCodeGenerator generator)
{
var season = new Season(2017);
var eventInfo = new EventInformation("Germany", "Hockenheim", 7, new DateTime(2017, 2, 3));
var sut = new Race(season, eventInfo);
var code = generator.Generate();
Assert.Throws <ArgumentException>(() => sut.SetParticipatingDrivers(code, code));
}
internal void CalculateReferenceTime_AsSpecificDriver_FromRaceData(ReferenceTimeCalculator referenceTimeCalculator,
DriverCodeGenerator driverCodeGenerator,
LapDataGenerator lapDataGenerator,
string team)
{
var(drivers, raceData) = BuildRaceData(driverCodeGenerator, lapDataGenerator, team);
referenceTimeCalculator.SetStrategy(new SpecificDriverAverageReferenceTimeStrategy(drivers.ToArray()[2].DriverCode));
var referenceTime = referenceTimeCalculator.Calculate(drivers, raceData);
Assert.Equal(TimeSpan.FromSeconds(17), referenceTime.Time);
}
public void BuildRaceTrace_ShouldThrowException_WhenDriverLookupIsNull(
RaceTraceFactory raceTraceFactory,
DriverCodeGenerator driverCodeGenerator)
{
var driverRaceData = new DriverRaceData(driverCodeGenerator.Generate());
var raceData = new RaceData(driverRaceData);
var timeSpan = TimeSpan.FromTicks(TimeSpan.TicksPerMinute);
var referenceTime = new ReferenceTime(timeSpan.Minutes, timeSpan.Seconds, timeSpan.Milliseconds);
Assert.Throws <ArgumentNullException>(() => raceTraceFactory.Build(raceData, referenceTime, null));
}
internal void CalculateReferenceTime_AsWinnerAverage_FromRaceData(ReferenceTimeCalculator referenceTimeCalculator,
RaceWinnerAverageReferenceTimeStrategy raceWinnerAverageReferenceTimeStrategy,
DriverCodeGenerator driverCodeGenerator,
LapDataGenerator lapDataGenerator,
string team)
{
var(drivers, raceData) = BuildRaceData(driverCodeGenerator, lapDataGenerator, team);
referenceTimeCalculator.SetStrategy(raceWinnerAverageReferenceTimeStrategy);
var referenceTime = referenceTimeCalculator.Calculate(drivers, raceData);
Assert.Equal(TimeSpan.FromSeconds(2), referenceTime.Time);
}
public void BuildRaceTrace_ShouldThrowException_WhenReferenceTimeIsNull(
RaceTraceFactory raceTraceFactory,
DriverCodeGenerator driverCodeGenerator,
string driverName)
{
var driverRaceData = new DriverRaceData(driverCodeGenerator.Generate());
var raceData = new RaceData(driverRaceData);
var diverLookup = new Dictionary <DriverCode, string> {
{ driverCodeGenerator.Generate(), driverName }
};
Assert.Throws <ArgumentNullException>(() => raceTraceFactory.Build(raceData, null, diverLookup));
}
public void BuildRaceTrace_ShouldThrowException_WhenRaceDataIsNull(
RaceTraceFactory raceTraceFactory,
DriverCodeGenerator driverCodeGenerator,
string driverName)
{
var timeSpan = TimeSpan.FromTicks(TimeSpan.TicksPerMinute);
var referenceTime = new ReferenceTime(timeSpan.Minutes, timeSpan.Seconds, timeSpan.Milliseconds);
var diverLookup = new Dictionary <DriverCode, string> {
{ driverCodeGenerator.Generate(), driverName }
};
Assert.Throws <ArgumentNullException>(() => raceTraceFactory.Build(null, referenceTime, diverLookup));
}
public void SelectEntry_WithDriverCodeAsKey_WhenInDictionary(DriverCodeGenerator driverCodeGenerator, string stringValue)
{
var keyCode = driverCodeGenerator.Generate();
var expectedValue = "To Match";
var dictionary = new Dictionary <DriverCode, string>
{
{ keyCode, expectedValue },
{ driverCodeGenerator.Generate(), stringValue },
{ driverCodeGenerator.Generate(), stringValue },
{ driverCodeGenerator.Generate(), stringValue },
};
var resultValue = dictionary[new DriverCode(keyCode.Code)];
Assert.NotNull(resultValue);
Assert.Equal(expectedValue, resultValue);
}
public void MapToDriver_FromDto_ForSingleDriver(DriverMapper mapper, DriverCodeGenerator driverCodeGenerator, string team, string status)
{
var code = driverCodeGenerator.Generate().Code;
var drivers = new List <DriverDto> {
new DriverDto(code, "John", "Read")
};
var raceResultDto = new List <RaceResultDto>
{
new RaceResultDto(code, 1, team, status)
};
var driver = mapper.ToDriver(drivers, raceResultDto).Single();
Assert.Equal(new DriverCode(code), driver.DriverCode);
Assert.Equal(1, driver.FinishStatus.Position);
Assert.Equal(status, driver.FinishStatus.Status);
Assert.Equal(team, driver.Team);
Assert.NotNull(driver.Name);
}
public void MapOneDriver_FromImbalancedInputData_WithRaceDataForTwoDrivers(DriverMapper mapper,
DriverCodeGenerator driverCodeGenerator,
string team, string status)
{
var code = driverCodeGenerator.Generate().Code;
var drivers = new List <DriverDto>
{
new DriverDto(code, "John", "Read"),
};
var raceResultDto = new List <RaceResultDto>
{
new RaceResultDto(code, 1, team, status),
new RaceResultDto(driverCodeGenerator.Generate().Code, 2, team, status),
};
var driver = mapper.ToDriver(drivers, raceResultDto).Single();
Assert.Equal(new DriverCode(code), driver.DriverCode);
Assert.Equal("John", driver.Name.FirstName);
Assert.Equal("Read", driver.Name.Surname);
}
public void BuildRaceTrace_CalculatesTrace_ForSingleDriver(
RaceTraceFactory raceTraceFactory,
DriverCodeGenerator driverCodeGenerator,
LapDataGenerator lapDataGenerator,
string driverName)
{
var driverCode = driverCodeGenerator.Generate();
var driverRaceData = new DriverRaceData(driverCode);
var laps = lapDataGenerator.GenerateLaps(4);
foreach (var(lapTime, lapData) in laps)
{
driverRaceData.AddLap(lapTime, lapData);
}
var raceData = new RaceData(driverRaceData);
var timeSpan = TimeSpan.FromTicks(TimeSpan.TicksPerMinute);
var referenceTime = new ReferenceTime(timeSpan.Minutes, timeSpan.Seconds, timeSpan.Milliseconds);
var diverLookup = new Dictionary <DriverCode, string> {
{ driverCode, driverName }
};
var raceTrace = raceTraceFactory.Build(raceData, referenceTime, diverLookup);
Assert.NotNull(raceTrace);
Assert.Equal(1, raceTrace.DriverCodes.Count);
var traceData = raceTrace.GetDataForDriver(driverCode);
Assert.NotNull(traceData);
var traceLapDeltas = traceData.GetAllLaps();
Assert.Equal(4, traceLapDeltas.Count);
}
private (IReadOnlyCollection <Driver> Drivers, RaceData raceData) BuildRaceData(DriverCodeGenerator driverCodeGenerator,
LapDataGenerator lapDataGenerator,
string team)
{
var drivers = new List <Driver>
{
new Driver(new Name("DriverOne", "One"), driverCodeGenerator.Generate(), team,
new FinishStatus(new Position(1), "Finished")),
new Driver(new Name("DriverTwo", "Two"), driverCodeGenerator.Generate(), team,
new FinishStatus(new Position(2), "Finished")),
new Driver(new Name("DriverThree", "Three"), driverCodeGenerator.Generate(), team,
new FinishStatus(new Position(3), "Finished")),
};
var driverRaceData = new[]
{
BuildDriverRaceData(lapDataGenerator, drivers[0].DriverCode.Code,
new [] { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(3) }),
BuildDriverRaceData(lapDataGenerator, drivers[1].DriverCode.Code,
new [] { TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(11), TimeSpan.FromSeconds(12) }),
BuildDriverRaceData(lapDataGenerator, drivers[2].DriverCode.Code,
new [] { TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(17), TimeSpan.FromSeconds(19) }),
};
var raceData = new RaceData(driverRaceData);
return(drivers, raceData);
}
public void MatchDriverCode_ShouldSucceed_WhenCodeTheSame(DriverCodeGenerator driverCodeGenerator)
{
var driverCode = driverCodeGenerator.Generate();
Assert.Equal(driverCode, new DriverCode(driverCode.Code));
}
public void MapRaceData_MultipleDrivers_FromValidData(DriverLapTimesMapper mapper, DriverCodeGenerator driverCodeGenerator, LapDataGenerator lapDataGenerator)
{
var code1 = driverCodeGenerator.Generate();
var code2 = driverCodeGenerator.Generate();
var dict = new Dictionary <string, IReadOnlyCollection <LapDto> >
{
{ code1.Code, new List <LapDto>
{
new LapDto(lapDataGenerator.LapTimeSpan(), 1, 1),
} },
{ code2.Code, new List <LapDto>
{
new LapDto(lapDataGenerator.LapTimeSpan(), 1, 2),
new LapDto(lapDataGenerator.LapTimeSpan(), 2, 1),
} },
};
var driverLapTimes = mapper.DriverLapTimes(dict);
var raceData = mapper.ToRaceData(driverLapTimes);
Assert.NotNull(raceData);
Assert.Equal(2, raceData.DriverCodes.Count);
Assert.Equal(2, raceData.AllDriverRaceData.Count);
var allDriverData = raceData.AllDriverRaceData.ToArray();
Assert.Equal(1, allDriverData[0].TotalLapCount);
Assert.Equal(2, allDriverData[1].TotalLapCount);
}
public void MapRaceData_SingularDriver_FromValidData(DriverLapTimesMapper mapper, DriverCodeGenerator driverCodeGenerator, LapDataGenerator lapDataGenerator)
{
var code = driverCodeGenerator.Generate();
var dict = new Dictionary <string, IReadOnlyCollection <LapDto> >
{
{ code.Code, new List <LapDto>
{
new LapDto(lapDataGenerator.LapTimeSpan(), 1, 1),
new LapDto(lapDataGenerator.LapTimeSpan(), 2, 1),
new LapDto(lapDataGenerator.LapTimeSpan(), 3, 1),
} }
};
var driverLapTimes = mapper.DriverLapTimes(dict);
var raceData = mapper.ToRaceData(driverLapTimes);
Assert.NotNull(raceData);
Assert.Equal(1, raceData.DriverCodes.Count);
Assert.Equal(code, raceData.DriverCodes.Single());
Assert.Equal(1, raceData.AllDriverRaceData.Count);
Assert.Equal(3, raceData.AllDriverRaceData.Single().TotalLapCount);
Assert.Equal(code, raceData.AllDriverRaceData.Single().DriverCode);
}
public void MapDriverLapTime_MultipleDrivers_FromValidData(DriverLapTimesMapper mapper, DriverCodeGenerator driverCodeGenerator, LapDataGenerator lapDataGenerator)
{
var code1 = driverCodeGenerator.Generate();
var code2 = driverCodeGenerator.Generate();
var dict = new Dictionary <string, IReadOnlyCollection <LapDto> >
{
{ code1.Code, new List <LapDto>
{
new LapDto(lapDataGenerator.LapTimeSpan(), 1, 1),
} },
{ code2.Code, new List <LapDto>
{
new LapDto(lapDataGenerator.LapTimeSpan(), 1, 2),
} },
};
var driverLapTimes = mapper.DriverLapTimes(dict);
Assert.NotNull(driverLapTimes);
Assert.Equal(2, driverLapTimes.Count);
Assert.True(driverLapTimes.All(x => x.LapInformation.Count == 1));
}
public void MapDriverLapTime_SingularDriver_FromValidData(DriverLapTimesMapper mapper, DriverCodeGenerator driverCodeGenerator, LapDataGenerator lapDataGenerator)
{
var code = driverCodeGenerator.Generate();
var dict = new Dictionary <string, IReadOnlyCollection <LapDto> >
{
{ code.Code, new List <LapDto>
{
new LapDto(lapDataGenerator.LapTimeSpan(), 1, 1),
new LapDto(lapDataGenerator.LapTimeSpan(), 2, 1),
new LapDto(lapDataGenerator.LapTimeSpan(), 3, 1),
} }
};
var driverLapTimes = mapper.DriverLapTimes(dict);
Assert.NotNull(driverLapTimes);
Assert.Equal(1, driverLapTimes.Count);
Assert.Equal(3, driverLapTimes.First(x => x.DriverCode == code.Code).LapInformation.Count);
Assert.Equal(code.Code, driverLapTimes.First().DriverCode);
}
