public void CalcAverageHorsePower_ThrowsException_WhenDriversAreLessThanMinimum()
{
this.raceEntry.AddDriver(unitDriver);
Assert.Throws <InvalidOperationException>
(() => raceEntry.CalculateAverageHorsePower());
}
public void CalculateAverageHorsePower_ThrowException_WhenBelowMin()
{
Assert.Throws <InvalidOperationException>(() =>
{
raceEntry.CalculateAverageHorsePower();
});
}
public void Test_Should_Throw_InvalidOperationException()
{
Assert.Throws <InvalidOperationException>(() => raceEntry.AddRider(null));
raceEntry.AddRider(unitRider);
Assert.Throws <InvalidOperationException>(() => raceEntry.AddRider(unitRider));
Assert.Throws <InvalidOperationException>(() => raceEntry.CalculateAverageHorsePower());
}
public void CalculateAverageHorsePower_ThrowsException_WhenParticipantsAreNotEnough()
{
string name = "Stancho";
testEntry.AddDriver(CreateSimpleDriver(name));
Assert.Throws <InvalidOperationException>(() => testEntry.CalculateAverageHorsePower());
}
public void CalculateAvrgHP_ThrowsException_WhenParticipantsAreLess()
{
Assert.Throws <InvalidOperationException>(() => raceEntry.CalculateAverageHorsePower());
raceEntry.AddDriver(new UnitDriver("Sena", new UnitCar("MC", 5000, 500)));
Assert.Throws <InvalidOperationException>(() => raceEntry.CalculateAverageHorsePower());
}
public void CalculateAverageHorsePower_ThrowsException_WhenDriversAreLessThanMinimum()
{
UnitCar car = new UnitCar("Model", 100, 500);
UnitDriver driver = new UnitDriver("Name", car);
raceEntry.AddDriver(driver);
Assert.Throws <InvalidOperationException>(() => raceEntry.CalculateAverageHorsePower());
}
public void CalculateAverageHorsePowerShouldThrowExWhenRaceInvalid()
{
raceEntry.AddRider(unitRider);
Assert.Throws <InvalidOperationException>(() =>
{
double res = raceEntry.CalculateAverageHorsePower();
}, "The race cannot start with less than 2 participants.");
}
public void When_CalculateAverageHorsePower_ShouldThrowWhenDriverAreLesThanTwo()
{
UnitDriver driverOper = new UnitDriver("Angel", new UnitCar("Opel", 32, 4000));
race.AddDriver(driverOper);
Assert.Throws <InvalidOperationException>(() => race.CalculateAverageHorsePower());
}
public void CalculateAverageHorsePower_ThrowsException_WhenLessParticipants()
{
Assert.Throws <InvalidOperationException>(() => raceEntry.CalculateAverageHorsePower());
raceEntry.AddDriver(new UnitDriver("Masko", new UnitCar("Tesla", 500, 8000)));
Assert.Throws <InvalidOperationException>(() => raceEntry.CalculateAverageHorsePower());
}
public void CalculateAverageHorsePowerThrows_When_ThereArenotEnoughParticipants()
{
raceEntry.AddDriver(driver);
Assert.That(() =>
{
raceEntry.CalculateAverageHorsePower();
}, Throws.InvalidOperationException.With.Message.EqualTo($"The race cannot start with less than 2 participants."));
}
public void CannotStartWithoutMinParticipans()
{
raceEntry.AddRider(rider);
Assert.Throws <InvalidOperationException>(() =>
{
raceEntry.CalculateAverageHorsePower();
});
}
public void MinPartisipantsIncalculateAverageHP()
{
raceEntry.AddDriver(driver);
Assert.Throws <InvalidOperationException>(() =>
{
raceEntry.CalculateAverageHorsePower();
});
}
public void TestCalculatingHorsePower()
{
UnitDriver driver2 = new UnitDriver("Boris", new UnitCar("Mazda", 90, 1000));
race.AddDriver(driver);
race.AddDriver(driver2);
double horsePower = race.CalculateAverageHorsePower();
Assert.AreEqual(horsePower, 120);
}
public void CalculateAvgHorsePowerWorksCorrectly()
{
UnitDriver ud1 = new UnitDriver("Name1", new UnitCar("model1", 100, 123));
UnitDriver ud2 = new UnitDriver("Name2", new UnitCar("model2", 110, 123));
raceEntry.AddDriver(ud1);
raceEntry.AddDriver(ud2);
var hp = raceEntry.CalculateAverageHorsePower();
Assert.AreEqual(hp, 105);
}
public void CalculateAverageHorsePower_ShouldThrowWhenNotEnoughtPeople()
{
var driver1 = new UnitDriver("Pesho", new UnitCar("bmw", 350, 520));
var result = race.AddDriver(driver1);
Assert.Throws <InvalidOperationException>(() =>
{
race.CalculateAverageHorsePower();
});
}
public void CalculateAvarageHorsePower_ShouldThrowExeption_WhenThereIsLessThanConstantDrivers()
{
int minumumParticipants = 2;
UnitDriver driver1 = new UnitDriver("Pesho", car);
race.AddDriver(driver1);
Assert.Throws <InvalidOperationException>(() =>
{
race.CalculateAverageHorsePower();
}, $"The race cannot start with less than {minumumParticipants} participants.");
}
public void AverageHorsePowerShouldWorkCorrectly()
{
var expectedResult = 80;
var rider = new UnitRider("Michael", motor);
var rider2 = new UnitRider("John", motor);
race.AddRider(rider);
race.AddRider(rider2);
var actualResult = race.CalculateAverageHorsePower();
Assert.AreEqual(expectedResult, actualResult);
}
public void RaceEntry_CalculateAverageHorsePower()
{
var motorcycle1 = new UnitMotorcycle("1", 10, 5.5);
var motorcycle2 = new UnitMotorcycle("2", 20, 54.5);
var racer1 = new UnitRider("name1", motorcycle1);
var racer2 = new UnitRider("name2", motorcycle2);
this.raceEntry.AddRider(racer1);
this.raceEntry.AddRider(racer2);
Assert.AreEqual(15, raceEntry.CalculateAverageHorsePower());
}
public void RaceEntryCalculateAverageHorsePower()
{
var race = new RaceEntry();
Assert.Throws <InvalidOperationException>(() => race.CalculateAverageHorsePower());
var moto = new UnitMotorcycle("a", 4, 4);
var rider = new UnitRider("a", moto);
var nextRider = new UnitRider("b", moto);
race.AddRider(rider);
race.AddRider(nextRider);
Assert.That(race.Counter == 2);
Assert.That(race.CalculateAverageHorsePower() == 4);
}
public void Calcul_Avarage_Horse_Power_less_Then_Two_Drivers_Throw_Message()
{
testEntry.AddDriver(testDriver);
//UnitCar testCarTwo = new UnitCar("Testy", 1, 1);
//UnitDriver secondDriver = new UnitDriver("Bo", testCarTwo);
InvalidOperationException ex = Assert.Throws <InvalidOperationException>(() =>
{
testEntry.CalculateAverageHorsePower();
});
Assert.AreEqual(ex.Message, "The race cannot start with less than 2 participants.");
}
public void ThrowExceptionWhenLessThen2RidersInRaceToCalculateAverageHorsePower()
{
RaceEntry race = new RaceEntry();
UnitRider rider = new UnitRider("Ivan", new UnitMotorcycle("SX1", 100, 2000));
Assert.Throws <InvalidOperationException>(() => race.CalculateAverageHorsePower());
}
public void TestAverageHorsePowerOfRiders()
{
string model1 = "Imaha";
int horsePower1 = 100;
double cubicCentimeters1 = 150.5;
var motorcycle1 = new UnitMotorcycle(model1, horsePower1, cubicCentimeters1);
string model2 = "Imaha2";
int horsePower2 = 100;
double cubicCentimeters2 = 150.5;
var motorcycle2 = new UnitMotorcycle(model2, horsePower2, cubicCentimeters2);
string name1 = "Ivan1";
UnitRider rider1 = new UnitRider(name1, motorcycle1);
string name2 = "Ivan2";
UnitRider rider2 = new UnitRider(name2, motorcycle2);
var race = new RaceEntry();
race.AddRider(rider1);
race.AddRider(rider2);
Assert.AreEqual(100, race.CalculateAverageHorsePower());
}
public void CalculateAverageHorseGetAvaregeHpWhenThereAreMoreThanTwoRaicers()
{
var race = new RaceEntry();
var motorcycle = new UnitMotorcycle("BMW", 80, 2341.12);
var motorcycle1 = new UnitMotorcycle("Yamaha", 120, 1020.12);
var motorcycle2 = new UnitMotorcycle("KTM", 104, 1241.12);
var rider = new UnitRider("Pesho", motorcycle);
var rider1 = new UnitRider("Gosho", motorcycle1);
var rider2 = new UnitRider("Kurti", motorcycle2);
race.AddRider(rider);
race.AddRider(rider1);
race.AddRider(rider2);
var list = new List <UnitRider>();
list.Add(rider);
list.Add(rider1);
list.Add(rider2);
var value = list.Select(x => x.Motorcycle.HorsePower)
.Average();
Assert.AreEqual(value, race.CalculateAverageHorsePower());
}
public void CheckIfLastCommandThrowsExByExistingRider()
{
RaceEntry second = new RaceEntry();
Assert.Throws <InvalidOperationException>(() =>
second.CalculateAverageHorsePower());
}
public void TestIfCalculateAverageHorsePowerCommandWorksCorrectly()
{
double expectedAverageHP = 100;
UnitMotorcycle motorcycle = new UnitMotorcycle("Suzuki", 100, 1000);
UnitMotorcycle secondMotorcycle = new UnitMotorcycle("Porti", 100, 1000);
UnitRider rider = new UnitRider("ilko", motorcycle);
UnitRider secondRider = new UnitRider("Sasho", secondMotorcycle);
raceEntry.AddRider(rider);
raceEntry.AddRider(secondRider);
double averageHP = raceEntry.CalculateAverageHorsePower();
Assert.AreEqual(expectedAverageHP, averageHP);
}
public void CalculateAverage_ShouldThrowExc1()
{
RaceEntry race = new RaceEntry();
race.AddDriver(new UnitDriver("pesho", car));
Assert.Throws <InvalidOperationException>(() => race.CalculateAverageHorsePower());
}
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 CalculatingMinPowerWithLessThanMinParticipantsShouldThrowException()
{
RaceEntry raceEntry = new RaceEntry();
raceEntry.AddRider(unitRider1);
Assert.Throws <InvalidOperationException>(() => raceEntry.CalculateAverageHorsePower());
}
public void TestCalculateHorsePowerOneCompetitor()
{
UnitMotorcycle umc = new UnitMotorcycle("Kawazaki", 300, 1500);
UnitRider ur = new UnitRider("UniteRider", umc);
re.AddRider(ur);
r.Add(ur.Name, ur);
//double expectedHorsePower = 300;
double actualHorsePower = r.Values.Select(x => x.Motorcycle.HorsePower).Average();
Assert.Throws <InvalidOperationException>(() =>
{
re.CalculateAverageHorsePower();
});
}
public void LastMethod()
{
var driver = new UnitDriver("Test", new UnitCar("bobi", 1, 1));
var driver2 = new UnitDriver("Test2", new UnitCar("bobi", 1, 1));
var driver3 = new UnitDriver("Test3", new UnitCar("bobi", 1, 1));
var race = new RaceEntry();
Assert.Throws <InvalidOperationException>(() => race.CalculateAverageHorsePower());
race.AddDriver(driver);
race.AddDriver(driver2);
race.AddDriver(driver3);
var num = race.CalculateAverageHorsePower();
Assert.AreEqual(num, 1);
}
