public void Drive_Should_Decreased_Fuel_Amount(
string make,
string model,
double fuelConsumption,
double fuelCapacity,
double FuelToRefuel,
double distanceToDrive)
{
//Arrange
car = new Car(
make: make,
model: model,
fuelConsumption: fuelConsumption,
fuelCapacity: fuelCapacity);
//Act
car.Refuel(FuelToRefuel);
double carCurrFuelAmount = car.FuelAmount;
car.Drive(distanceToDrive);
//Assert
double carDistanceFuelAmount = (distanceToDrive / 100) * fuelConsumption;
double expectedCarFuelAmountResult = carCurrFuelAmount - carDistanceFuelAmount;
double actualCarFuelAmountResult = car.FuelAmount;
Assert.AreEqual(expectedCarFuelAmountResult, actualCarFuelAmountResult);
}
public void TestIfRefuelMethodThrowsExceptionWhenInputIsInvalid()
{
Car car = new Car("Audi", "A4", 7, 60);
Assert.Throws <ArgumentException>(() => car.Refuel(-20));
}
public void When_RefuelCall_ShuoldSetFuelToMaxCapacityIfBigger()
{
Car car = new Car("make", "model", 4, 5);
int newFuel = 6;
car.Refuel(newFuel);
Assert.AreEqual(car.FuelAmount, car.FuelCapacity);
}
public void CarMethodDriveShouldWorkNormallyAndDecreaceFuelAmount()
{
var car = new Car("Peugeot", "406", 12.5, 40);
car.Refuel(25);
car.Drive(50);
Assert.AreEqual(18.75, car.FuelAmount);
}
public void TestIfDistanceIfMoreThanFuelException(double distanceToDrive)
{
Car car4 = new Car("VW", "Passat", 10, 20);
car4.Refuel(20);
Assert.Throws <InvalidOperationException>(() => car4.Drive(distanceToDrive));
}
public void RefuelWorksProperly(double fuelAmount, double expectedFuel)
{
Car car = new Car("make", "model", 10, 100);
car.Refuel(fuelAmount);
Assert.AreEqual(expectedFuel, car.FuelAmount);
}
public void DriveMethodWorksCorrectly()
{
Car testCar = new Car("123", "123", 4, 4);
testCar.Refuel(4);
testCar.Drive(100);
Assert.AreEqual(testCar.FuelAmount, 0);
}
public void CheckTheTankOverflow(double fuelToRefuel)
{
Car car = new Car("volvo", "S80", 20, 60);
car.Refuel(fuelToRefuel);
Assert.AreEqual(60, car.FuelAmount);
}
public void CheckTheExceptionForInsufficientFuel(double distance)
{
Car car = new Car("volvo", "S80", 20, 60);
car.Refuel(10);
Assert.Throws <InvalidOperationException>(() => car.Drive(distance), "You don't have enough fuel to drive!");
}
public void RefuelShouldThrowExceptionWhenPassedValueIsBelowOrEqualToZero
(double value)
{
Car car = new Car("VW", "Golf", 10, 100);
Assert.Throws <ArgumentException>(() =>
car.Refuel(value));
}
public void RefuelShouldThrowExceptionIfFuelIsBellowOrZero(double fuel)
{
//Arrange
Car car = new Car("VW", "Golf", 10, 100);
//Act - Assert
Assert.Throws <ArgumentException>(() => car.Refuel(fuel));
}
public void RefuelMethodShouldWorksCorrectly(double fuelToRefuel)
{
var car = new Car("Germany", "BMW", 10, 45);
car.Refuel(fuelToRefuel);
Assert.AreEqual(car.FuelAmount, 12);
}
public void TestRefuel()
{
var car = new Car(5);
car.Refuel(40);
Assert.AreEqual(45, car.fuelTankDisplay.FillLevel, "Wrong fuel tank fill level!");
}
public void RefuelThrowsArgumentExceptionWithZeroOrNegativeAmount(int amount)
{
var car = new Car(" ", " ", 10, 65);
var exception = Assert.Throws <ArgumentException>(() => car.Refuel(amount));
Assert.AreEqual("Fuel amount cannot be zero or negative!", exception.Message);
}
public void DriveWithSuficientFuelAmount()
{
var car = new Car(make, model, fuelConsumption, fuelCapacity);
car.Refuel(100.00);
car.Drive(300);
Assert.That(car.FuelAmount, Is.EqualTo(78.40));
}
public void CheckWheterRefuelMethodThrowsExceptionIfArgumentIsLessOrEqualsToZero(double fuelToRefuel)
{
car = new Car("BMW", "E90", 0.5, 60);
Assert.Throws <ArgumentException>(() =>
{
car.Refuel(fuelToRefuel);
});
}
public void RefuellingShoulddWorkCorrectly
(double fuel, double expectedFuel)
{
Car car = new Car("AAA", "bbb", 5.00, 50.00);
car.Refuel(fuel);
Assert.AreEqual(car.FuelAmount, expectedFuel);
}
public void ValidationInRefuellingAmountShoulddWorkCorrectly
(double fuel)
{
Car car = new Car("AAA", "bbb", 5.00, 50.00);
Assert.Throws <ArgumentException>(()
=> car.Refuel(fuel));
}
public void DriveThrowsException()
{
Car car = new Car("make", "model", 10, 100);
car.Refuel(1);
Assert.Throws <InvalidOperationException>(() => car.Drive(100));
}
public void CarWithZeroOrNegativeRefuelAmount_ShouldThrowException(double refuelAmount)
{
//Arrange
var car = new Car("VW", "Golf", defaultFuelConsumption, defaultFuelCapacity);
//Act - Assert
Assert.Throws <ArgumentException>(() => car.Refuel(refuelAmount));
}
public void Test1()
{
car.Refuel(10);
car.Drive(10);
Assert.That(car.FuelAmount, Is.EqualTo(9));
}
public void TestRefuelWorkCorrectly()
{
double expectedFuelAmount = 4;;
car.Refuel(4);
Assert.AreEqual(expectedFuelAmount, car.FuelAmount);
}
public void TestIfRefuelMoreThanCapacity()
{
Car car = new Car("BMW", "MK3", 10, 70);
car.Refuel(100);
int expectedFuel = 70;
Assert.AreEqual(expectedFuel, car.FuelAmount);
}
public void RefuelWorksFine(int amount)
{
var car = new Car(" ", " ", 10, 65);
var expectedAmount = Math.Min(amount, car.FuelCapacity);
car.Refuel(amount);
Assert.AreEqual(expectedAmount, car.FuelAmount);
}
public void CheckTheFuelAmountNextDrive()
{
Car car = new Car("volvo", "S80", 20, 60);
car.Refuel(60);
car.Drive(100);
Assert.AreEqual(40, car.FuelAmount);
}
public void TestRefuelWithZero()
{
Car car = new Car("BMW", "MK3", 10, 70);
Assert.Throws <ArgumentException>(() =>
{
car.Refuel(0);
});
}
public void RefuelThrowsAEWhenFuelToRefuelIsEqualOrBelowZero
(double amount)
{
//Arrange
Car car = new Car("A", "B", 10, 100);
//Act && Arrange
Assert.Throws <ArgumentException>(() => car.Refuel(amount));
}
public void DriveWorksProperly()
{
Car car = new Car("make", "model", 10, 100);
car.Refuel(100);
car.Drive(100);
Assert.AreEqual(90, car.FuelAmount);
}
public void TestRefuelWithNegativeNumber()
{
Car car = new Car("BMW", "MK3", 10, 70);
Assert.Throws <ArgumentException>(() =>
{
car.Refuel(-10);
});
}
public void RefuelMethodThrowsExceptionIfFuelIsZeroOrNegative()
{
Car testCar = new Car("123", "123", 4, 4);
Assert.Throws <ArgumentException>(() =>
{
testCar.Refuel(-1);
});
}
