public void Is_Calculate_Average_Horse_Power_Returns_Correct_Result(
string model, int horsePower, double cubicCentimeters,
string model1, int horsePower1, double cubicCentimeters1,
string model2, int horsePower2, double cubicCentimeters2,
string name, string name1, string name2)
{
//Arrange
UnitCar unitCar = new UnitCar(model, horsePower, cubicCentimeters);
UnitCar unitCar1 = new UnitCar(model1, horsePower1, cubicCentimeters1);
UnitCar unitCar2 = new UnitCar(model2, horsePower2, cubicCentimeters2);
UnitDriver unitDriver = new UnitDriver(name, unitCar);
UnitDriver unitDriver1 = new UnitDriver(name1, unitCar1);
UnitDriver unitDriver2 = new UnitDriver(name2, unitCar2);
//Act
RaceEntry raceEntry = new RaceEntry();
raceEntry.AddDriver(unitDriver);
raceEntry.AddDriver(unitDriver1);
raceEntry.AddDriver(unitDriver2);
//Assert
Double expectedResult = (double)(horsePower + horsePower1 + horsePower2) / 3;
Assert.AreEqual(expectedResult, raceEntry.CalculateAverageHorsePower());
}
public void TestMethodAddShouldThrowInvalidOperationExceptionIfDriverAlreadyInCollection()
{
UnitCar car = new UnitCar("A", 10, 10.5);
RaceEntry race = new RaceEntry();
race.AddDriver(new UnitDriver("A", car));
Assert.Throws <InvalidOperationException>(() => race.AddDriver(new UnitDriver("A", car)));
}
public void AddingExistingDriverShouldThrowException()
{
RaceEntry race = new RaceEntry();
race.AddDriver(achoDriver);
Assert.Throws <InvalidOperationException>(()
=> race.AddDriver(achoDriver));
}
public void AddDriver_ShouldWork()
{
RaceEntry race = new RaceEntry();
race.AddDriver(new UnitDriver("pesho", car));
race.AddDriver(new UnitDriver("gosho", new UnitCar("mercedes", 100, 20)));
Assert.AreEqual(2, race.Counter);
}
public void IfDrivenContains_ShouldThrowExc()
{
RaceEntry race = new RaceEntry();
race.AddDriver(new UnitDriver("Pesho", car));
UnitDriver driver = new UnitDriver("Pesho", car);
Assert.Throws <InvalidOperationException>(() => race.AddDriver(driver));
}
public void AddDriverExceptionWhenExisting()
{
RaceEntry drivers = new RaceEntry();
UnitCar unitCar = new UnitCar("Unit", 150, 2000.0d);
UnitDriver driver = new UnitDriver("Driver", unitCar);
drivers.AddDriver(driver);
Assert.Throws <InvalidOperationException>(() => drivers.AddDriver(driver));
}
public void ExceptionDriverExists()
{
RaceEntry race = new RaceEntry();
UnitCar car = new UnitCar("a", 100, 3000);
UnitDriver driver = new UnitDriver("joro", car);
race.AddDriver(driver);
Assert.Throws <InvalidOperationException>(() => race.AddDriver(driver));
}
public void AddExistDr()
{
RaceEntry race = new RaceEntry();
UnitCar car = new UnitCar("model", 3000, 250);
UnitDriver driver = new UnitDriver("name", car);
race.AddDriver(driver);
Assert.Throws <InvalidOperationException>(() => race.AddDriver(driver));
}
public void AddingExistingDriverShouldThrowException()
{
var validCar = new UnitCar("BMW", 100, 250);
var driver = new UnitDriver("anko", validCar);
var raceEntry = new RaceEntry();
raceEntry.AddDriver(driver);
Assert.Throws <InvalidOperationException>(() => raceEntry.AddDriver(driver));
}
public void RaceAddDriverException()
{
UnitCar car = new UnitCar("CZ", 100, 5.5);
UnitDriver driver = new UnitDriver("A", car);
RaceEntry race = new RaceEntry();
race.AddDriver(driver);
Assert.That(() => race.AddDriver(driver), Throws.InvalidOperationException.With.Message
.EqualTo(string.Format("Driver {0} is already added.",driver.Name)));
}
public void CalculateAverageHorsePowerShouldWork()
{
var raceEntry = new RaceEntry();
var driver = new UnitDriver("pesho", new UnitCar("lada", 100, 100));
var driver2 = new UnitDriver("gosho", new UnitCar("bmw", 180, 100));
raceEntry.AddDriver(driver);
raceEntry.AddDriver(driver2);
Assert.AreEqual(140, raceEntry.CalculateAverageHorsePower());
}
public void TestCounter()
{
raceEntry.AddDriver(driver);
raceEntry.AddDriver(new UnitDriver("Boiko Borisov", new UnitCar("Lada", 45, 1400)));
Assert.AreEqual(2, raceEntry.Counter);
}
public void Counter_IncreasesWhenAddDriver()
{
raceEntry.AddDriver(new UnitDriver("Sena", new UnitCar("Reno", 4000, 400)));
raceEntry.AddDriver(new UnitDriver("Prost", new UnitCar("BMW", 5000, 500)));
Assert.That(raceEntry.Counter, Is.EqualTo(2));
}
public void AddDriverDriverExist()
{
Assert.Throws <InvalidOperationException>(() =>
{
UnitCar car = new UnitCar("golf", 100, 2000);
UnitDriver driver = new UnitDriver("gosho", car);
RaceEntry race = new RaceEntry();
race.AddDriver(driver);
race.AddDriver(driver);
});
}
public void WhenAddingExistedDriver_ExceptionShouldBeTrown()
{
Assert.Throws <InvalidOperationException>(() =>
{
UnitCar car = new UnitCar("Ferrari", 200, 300);
UnitDriver driver = new UnitDriver("Pesho", car);
RaceEntry raceEx = new RaceEntry();
raceEx.AddDriver(driver);
raceEx.AddDriver(driver);
});
}
public void AddDriverShouldThrowExceptionWhenExsistingDriver()
{
var raceEntry = new RaceEntry();
var driver = new UnitDriver("pesho", new UnitCar("lada", 146, 86));
raceEntry.AddDriver(driver);
Assert.Throws <InvalidOperationException>(() =>
{
raceEntry.AddDriver(driver);
});
}
public void RaceCalcMethotTest()
{
UnitCar car = new UnitCar("CZ", 100, 5.5);
UnitDriver driver = new UnitDriver("A", car);
UnitDriver driverTwo = new UnitDriver("B", car);
RaceEntry race = new RaceEntry();
race.AddDriver(driver);
race.AddDriver(driverTwo);
double avrgPower = race.CalculateAverageHorsePower();
Assert.That(avrgPower, Is.EqualTo(100));
}
public void AddDriverExcWithExistingDriver()
{
var raceEntry = new RaceEntry();
var unitCar = new UnitCar("model", 10, 10);
var unidDriver = new UnitDriver("Gosho", unitCar);
raceEntry.AddDriver(unidDriver);
Assert.Throws <InvalidOperationException>(() => raceEntry.AddDriver(unidDriver));
}
public void ShouldThrowException_WhenAddDriverNull()
{
Exception ex = Assert.Throws <InvalidOperationException>(() =>
{
race.AddDriver(null);
});
Assert.AreEqual(ex.Message, "Driver cannot be null.");
}
public void AddDriver_Should_ThrowExeptionWhenDriverIsNull()
{
UnitDriver driver = null;
Assert.Throws <InvalidOperationException>(() =>
{
race.AddDriver(driver);
}, "Driver cannot be null.");
}
public void CalculateAverageHorsePowerWithMinParticipantsWorksAsExpected(string nameOne, string nameTwo)
{
var validCar = new UnitCar("BMW", 100, 250);
var driverOne = new UnitDriver(nameOne, validCar);
var driverTwo = new UnitDriver(nameTwo, validCar);
var raceEntry = new RaceEntry();
raceEntry.AddDriver(driverOne);
raceEntry.AddDriver(driverTwo);
Assert.AreEqual(100, raceEntry.CalculateAverageHorsePower());
}
public void RaceAddDriver()
{
UnitCar car = new UnitCar("CZ", 100, 5.5);
UnitDriver driver = new UnitDriver("A", car);
RaceEntry race = new RaceEntry();
race.AddDriver(driver);
Assert.That(race.Counter, Is.EqualTo(1));
UnitDriver driverTwo = new UnitDriver("B", car);
race.AddDriver(driverTwo);
Assert.That(race.Counter, Is.EqualTo(2));
}
public void Add_Driver_Should_Throw_An_Exception_If_The_Driver_Is_Existing()
{
var raceEntry = new RaceEntry();
var car = new UnitCar("R8", 100, 2000);
var driver = new UnitDriver("Ivan", car);
raceEntry.AddDriver(driver);
Assert.Throws <InvalidOperationException>(
() => raceEntry.AddDriver(driver),
"The driver is not existing.");
}
public void CalculateMethodShouldWorkCorrectly()
{
RaceEntry race = new RaceEntry();
var car2 = new UnitCar("Aveo", 101, 1100.00);
var driver1 = new UnitDriver("Ely", car2);
race.AddDriver(driver1);
race.AddDriver(achoDriver);
double expectedValue = (car2.HorsePower + alfaCar.HorsePower) / 2;
Assert.AreEqual(expectedValue, race.CalculateAverageHorsePower());
}
public void MethodAddDriverShouldThrowExceptionIfExistingDriverIsGiven()
{
//Arrange
RaceEntry raceEntry = new RaceEntry();
UnitDriver unitDriver = new UnitDriver("Pesho", new UnitCar("BMW", 160, 3000));
//Act
raceEntry.AddDriver(unitDriver);
//Assert
Assert.Throws <InvalidOperationException>(()
=> raceEntry.AddDriver(unitDriver));
}
public void CalcAverageWork()
{
UnitCar car1 = new UnitCar("golf", 100, 2000);
UnitDriver driver1 = new UnitDriver("gosho", car1);
UnitCar car2 = new UnitCar("lada", 300, 2000);
UnitDriver driver2 = new UnitDriver("pesho", car2);
RaceEntry race = new RaceEntry();
race.AddDriver(driver1);
race.AddDriver(driver2);
Assert.AreEqual(race.CalculateAverageHorsePower(), 200);
}
public void TestMethodAddShouldReturnCorectAverageHorsePower()
{
UnitCar car = new UnitCar("A", 10, 10.5);
UnitCar carTwo = new UnitCar("B", 10, 10.5);
RaceEntry race = new RaceEntry();
race.AddDriver(new UnitDriver("A", car));
race.AddDriver(new UnitDriver("B", carTwo));
Assert.AreEqual(10, race.CalculateAverageHorsePower());
}
public void TestIfDriverIsTheSameException()
{
var race = new RaceEntry();
var car = new UnitCar("BMW", 100, 3000);
var driver = new UnitDriver("Pesho", car);
race.AddDriver(driver);
Assert.Throws <InvalidOperationException>(() =>
{
race.AddDriver(driver);
});
}
public void AddDriver_ThrowException_WhenNameIsNull()
{
Assert.Throws <ArgumentNullException>(() =>
{
raceEntry.AddDriver(new UnitDriver(null, defaultCar));
});
}
public void When_Adding_Existing_Driver_Invalid_Operation_Exception_Should_Be_Thrown()
{
// Arange
RaceEntry raceEntry = new RaceEntry();
UnitCar unitCar = new UnitCar("Test 5000", 420, 69);
UnitDriver unitDriver = new UnitDriver("Test", unitCar);
UnitDriver sameUnitDriver = new UnitDriver("Test", unitCar);
raceEntry.AddDriver(unitDriver);
// Act - Assert
Assert.Throws <InvalidOperationException>(() => raceEntry.AddDriver(sameUnitDriver),
"Driver Test is already added.");
}
