public void RemoveTest()
{
//Arrange
var capatity1 = 2;
var garage1 = new Garage <Vehicle>(capatity1);
var item1 = mockDataSource[Rnd.Next(0, mockDataSource.Count - 1)];
var item2 = mockDataSource[Rnd.Next(0, mockDataSource.Count - 1)];
var item3 = mockDataSource[Rnd.Next(0, mockDataSource.Count - 1)];
while (item1.Eq(item2))
{
item2 = mockDataSource[Rnd.Next(0, mockDataSource.Count - 1)];
}
while (item1.Eq(item3) || item2.Eq(item3))
{
item3 = mockDataSource[Rnd.Next(0, mockDataSource.Count - 1)];
}
garage1.Add(item1);
garage1.Add(item2);
var wasfull = garage1.IsFull;
//act
var result4 = garage1.Remove(item2);
Vehicle existsin1 = garage1.FirstOrDefault(v => v == item2);
var result5 = garage1.Remove(item3);
//assert
Assert.IsTrue(wasfull & (!garage1.IsFull), "When removing an element from a full garage the garage didn't get non-full");
Assert.IsNull(existsin1, "When removing an element the element wasn't removed");
Assert.IsFalse(result5, "when removings a non existing element the remove method retruern true");
}
public void Garage_Returnera_Vehicle_With_this_Test()
{
// Assert.Pass();
// Arrange
// expected
Guid guid = Guid.NewGuid();
Garage <ICanBeParkedInGarage> garage = new Garage <ICanBeParkedInGarage>(guid, "Garage 1", 5);
ICanBeParkedInGarage vehicle1 = new Car("AAA 111", "Röd", 4);
ICanBeParkedInGarage vehicle2 = new Bus("BBB 222", "Grön", 50);
garage.Add(vehicle1);
garage.Add(vehicle2);
// Act
// actual
ICanBeParkedInGarage actaulVehicle1 = garage[0];
Vehicle actualVec1 = actaulVehicle1 as Vehicle;
ICanBeParkedInGarage actaulVehicle2 = garage[1];
Vehicle actualVec2 = actaulVehicle2 as Vehicle;
// Assert
Assert.AreEqual(actualVec1.Color, ((Vehicle)vehicle1).Color);
Assert.AreEqual(actualVec2.Color, ((Vehicle)vehicle2).Color);
Assert.AreEqual(actualVec1.RegistrationNumber, ((Vehicle)vehicle1).RegistrationNumber);
Assert.AreEqual(actualVec2.RegistrationNumber, ((Vehicle)vehicle2).RegistrationNumber);
}
public void Garage_Vehicle_Count()
{
// public (string strId, string strName, bool bIsFull, int iCapacity, int iNumberOfParkedVehicle) GetGarageInfo()
// Assert.Pass();
// Arrange
// expected
Guid guid = Guid.NewGuid();
Garage <ICanBeParkedInGarage> garage = new Garage <ICanBeParkedInGarage>(guid, "Garage 1", 5);
ICanBeParkedInGarage vehicle1 = new Car("AAA 111", "Röd", 4);
ICanBeParkedInGarage vehicle2 = new Bus("BBB 222", "Grön", 50);
// Lägg till 2 fordon
garage.Add(vehicle1);
garage.Add(vehicle2);
// Act
// actual
int iActualNumberOfVehicles = garage.Count;
// Assert
Assert.AreEqual(2, iActualNumberOfVehicles);
}
public void RemoveTest()
{
//Arrange
var expectedgarage = new Garage <Vehicle>();
var car = new Car()
{
RegisterNumber = "aaa123"
};
var bus = new Bus()
{
RegisterNumber = "ddd123"
};
var boat = new Boat()
{
RegisterNumber = "eee123"
};
expectedgarage.Vehicles.Add(car);
expectedgarage.Vehicles.Add(bus);
expectedgarage.Vehicles.Add(boat);
expectedgarage.Vehicles.Remove(boat);
// Act
var actgarage = new Garage <Vehicle>();
actgarage.Add(car);
actgarage.Add(bus);
actgarage.Add(boat);
actgarage.Remove(boat);
//Assert
CollectionAssert.AreEqual(expectedgarage.Vehicles, actgarage.Vehicles);
}
public void Garage_Count_Number_Of_Vehicle_With_Registrationnumber()
{
// Assert.Pass();
// Arrange
// expected
Guid guid = Guid.NewGuid();
Garage <ICanBeParkedInGarage> garage = new Garage <ICanBeParkedInGarage>(guid, "Garage 1", 5);
ICanBeParkedInGarage vehicle1 = new Car("AAA 111", "Röd", 4);
ICanBeParkedInGarage vehicle2 = new Bus("BBB 222", "Grön", 50);
// Act
// actual
int iActualNumberOfVehicleBeforeAddedVehicle = garage.CountVehicleWithRegistrationNumber("AAA 111");
// Lägg till 2 fordon
garage.Add(vehicle1);
garage.Add(vehicle2);
int iActualNumberOfVehicleAfterAddedVehicle = garage.CountVehicleWithRegistrationNumber("AAA 111");
// Assert
Assert.AreEqual(0, iActualNumberOfVehicleBeforeAddedVehicle);
Assert.AreEqual(1, iActualNumberOfVehicleAfterAddedVehicle);
}
public void Garage_GetGarageInfo()
{
// public (string strId, string strName, bool bIsFull, int iCapacity, int iNumberOfParkedVehicle) GetGarageInfo()
// Assert.Pass();
// Arrange
// expected
Guid guid = Guid.NewGuid();
Garage <ICanBeParkedInGarage> garage = new Garage <ICanBeParkedInGarage>(guid, "Garage 1", 5);
ICanBeParkedInGarage vehicle1 = new Car("AAA 111", "Röd", 4);
ICanBeParkedInGarage vehicle2 = new Bus("BBB 222", "Grön", 50);
// Lägg till 2 fordon
garage.Add(vehicle1);
garage.Add(vehicle2);
// Act
// actual
var(strActualId, strActualName, bActualIsFull, iActualCapacity, iActualNumberOfParkedVehicle) = garage.GetGarageInfo();
// Assert
Assert.AreEqual(guid.ToString(), strActualId);
Assert.AreEqual("Garage 1", strActualName);
Assert.AreEqual(false, bActualIsFull);
Assert.AreEqual(5, iActualCapacity);
Assert.AreEqual(2, iActualNumberOfParkedVehicle);
}
public void Garage_AddCarToVehicleGarage_FailsGarageFull()
{
Garage <IVehicle> vehicleGarage = new Garage <IVehicle>(1);
Car car1 = new Car("ABC123", "Blue", 4, FuelType.Gasoline);
Car car2 = new Car("ABC456", "Green", 4, FuelType.Gasoline);
vehicleGarage.Add(car1);
Assert.IsFalse(vehicleGarage.Add(car2));
}
public void CountByTypeTest()
{
var garage = new Garage <Vehicle>(10);
var aCar = new Car("skj303", "blue", 5, 4, "BMW", "Petrol");
var bCar = new Car("skj304", "red", 4, 4, "Lambo", "Petrol");
var cCar = new Car("skj305", "green", 5, 4, "Seat", "Diesel");
var aBus = new Bus("skd493", "white", 60, 6, "Scania", "City bus");
var bBus = new Bus("skd494", "blue", 20, 4, "Mercedes", "Minibus");
var aTruck = new Truck("aak594", "green", 3, 16, "Volvo", 2500);
var bTruck = new Truck("aak595", "grey", 5, 18, "Mack", 3000);
var cTruck = new Truck("aak596", "black", 5, 14, "Scania", 2200);
var dTruck = new Truck("aak597", "orange", 3, 16, "Renault", 2500);
var done = "Bus: 2\nCar: 3\nTruck: 4\n";
var result1 = garage.CountByType();
garage.Add(aCar);
garage.Add(aBus);
garage.Add(bCar);
garage.Add(aTruck);
garage.Add(bTruck);
garage.Add(cCar);
garage.Add(cTruck);
garage.Add(bBus);
garage.Add(dTruck);
var result2 = garage.CountByType();
Assert.AreEqual(Garage <Vehicle> .garageEmpty, result1);
Assert.AreEqual(done, result2);
}
public void FindByPropertiesTest()
{
var garage = new Garage <Vehicle>(10);
var aCar = new Car("skj303", "blue", 5, 4, "BMW", "Petrol");
var bCar = new Car("skj304", "red", 4, 4, "Volvo", "Petrol");
var cCar = new Car("skj305", "green", 5, 4, "Seat", "Diesel");
var aBus = new Bus("skd493", "white", 60, 6, "Scania", "City bus");
var bBus = new Bus("skd494", "blue", 20, 4, "Mercedes", "Minibus");
var aTruck = new Truck("aak594", "green", 4, 16, "Volvo", 2500);
var bTruck = new Truck("aak595", "grey", 5, 18, "Mack", 3000);
var cTruck = new Truck("aak596", "black", 4, 14, "Scania", 2200);
var dTruck = new Truck("aak597", "blue", 3, 16, "Volvo", 2500);
var expected3 = $"{bBus.DisplayVehicleInformation()}\n{aCar.DisplayVehicleInformation()}\n{dTruck.DisplayVehicleInformation()}\n";
var expected4 = $"{bCar.DisplayVehicleInformation()}\n{aTruck.DisplayVehicleInformation()}\n";
var result1 = garage.FindByProperties("blue", 999, 4, "");
garage.Add(aCar);
garage.Add(aBus);
garage.Add(bCar);
garage.Add(aTruck);
garage.Add(bTruck);
garage.Add(cCar);
garage.Add(cTruck);
garage.Add(bBus);
garage.Add(dTruck);
var result3 = garage.FindByProperties("blue", 999, 999, "");
var result4 = garage.FindByProperties("", 4, 999, "Volvo");
var result5 = garage.FindByProperties("orange", 999, 8, "");
Assert.AreEqual(Garage <Vehicle> .garageEmpty, result1);
Assert.AreEqual(expected3, result3);
Assert.AreEqual(expected4, result4);
Assert.AreEqual(Garage <Vehicle> .missingVehicle, result5);
}
public void Garage_Add_To_Capacity_Vehicle_Test()
{
// Assert.Pass();
// Arrange
// expected
Guid guid = Guid.NewGuid();
Garage <ICanBeParkedInGarage> garage = new Garage <ICanBeParkedInGarage>(guid, "Garage 1", 5);
ICanBeParkedInGarage vehicle1 = new Car("AAA 111", "RÖD", 4);
ICanBeParkedInGarage vehicle2 = new Bus("BBB 222", "GRÖN", 50);
ICanBeParkedInGarage vehicle3 = new Car("CCC 333", "GRÖN", 4);
ICanBeParkedInGarage vehicle4 = new MotorCycle("DDD 444", "BLÅ", 2);
ICanBeParkedInGarage vehicle5 = new Car("EEE 555", "GRÖN", 5);
string strExpectedToString = $"Garage 1, Kapacitet: {5}, Antal parkerade fordon: {5}";
// Act
// actual
bool bAddedItem1 = garage.Add(vehicle1);
bool bAddedItem2 = garage.Add(vehicle2);
bool bAddedItem3 = garage.Add(vehicle3);
bool bAddedItem4 = garage.Add(vehicle4);
bool bAddedItem5 = garage.Add(vehicle5);
int iActualNumberOfVehicles = garage.Count;
bool bActualIsEmpty = garage.IsEmpty;
bool bActualIsFull = garage.IsFull;
string strActualToString = garage.ToString();
// Assert
Assert.IsTrue(bAddedItem1);
Assert.IsTrue(bAddedItem2);
Assert.IsTrue(bAddedItem3);
Assert.IsTrue(bAddedItem4);
Assert.IsTrue(bAddedItem5);
Assert.AreEqual(5, iActualNumberOfVehicles);
Assert.IsFalse(bActualIsEmpty);
Assert.IsTrue(bActualIsFull);
Assert.AreEqual(strExpectedToString, strActualToString);
}
public void Garage_Remove_Vehicle_At_Index_With_No_Vehicle_Test()
{
// Assert.Pass();
// Arrange
// expected
Guid guid = Guid.NewGuid();
Garage <ICanBeParkedInGarage> garage = new Garage <ICanBeParkedInGarage>(guid, "Garage 1", 5);
ICanBeParkedInGarage vehicle1 = new Car("AAA 111", "Röd", 4);
ICanBeParkedInGarage vehicle2 = new Car("BBB 222");
string strExpectedToStringBeforeRemove = $"Garage 1, Kapacitet: {5}, Antal parkerade fordon: {2}";
string strExpectedToStringAfterRemove = $"Garage 1, Kapacitet: {5}, Antal parkerade fordon: {2}";
// Act
// actual
bool bAddedItem1 = garage.Add(vehicle1);
bool bAddedItem2 = garage.Add(vehicle2);
string strActualBeforeToString = garage.ToString();
int iActualNumberOfVehiclesBeforeRemove = garage.Count;
bool bRemovedItem2 = garage.Remove(3);
int iActualNumberOfVehiclesAfterRemove = garage.Count;
bool bActualIsEmpty = garage.IsEmpty;
bool bActualIsFull = garage.IsFull;
string strActualAfterToString = garage.ToString();
// Assert
Assert.IsTrue(bAddedItem1);
Assert.IsTrue(bAddedItem2);
Assert.AreEqual(strExpectedToStringBeforeRemove, strActualBeforeToString);
Assert.AreEqual(2, iActualNumberOfVehiclesBeforeRemove);
Assert.IsFalse(bRemovedItem2);
Assert.AreEqual(2, iActualNumberOfVehiclesAfterRemove);
Assert.IsFalse(bActualIsEmpty);
Assert.IsFalse(bActualIsFull);
Assert.AreEqual(strExpectedToStringAfterRemove, strActualAfterToString);
}
public void AddToAFullGarage1()
{
// Arrange
var expected = 1;
var actual = garage.Count;
// Act
var car2 = new Car("aaa555", "Red", 4, "Diesel");
garage.Add(car2);
// Assert
Assert.IsTrue(garage.IsFull);
Assert.AreEqual(expected, actual);
}
public void AddVehToGarageCapacity0()
{
//Arrange
const int expected = 0;
//Act
var addTest = garage.Add(new Car("car123", "Red", 3, 3));
var actual = garage.vehLenght;
//Assert
Assert.IsFalse(addTest);
Assert.AreEqual(expected, actual);
}
public void CheckCountVehiclesTest()
{
var expected = 2;
var airplane = garage.Add(new Airplane("abc123", "white", 2, 3));
var car = garage.Add(new Car("abc124", "white", 2, "diesel"));
var actual = garage.Count;
//assert are equal
Assert.IsTrue(airplane);
Assert.IsTrue(car);
Assert.AreEqual(expected, actual);
}
public void SetUp()
{
garage = TestContext.TestName.EndsWith('0') ? new Garage <Vehicle>(0) : new Garage <Vehicle>(8);
if (TestContext.TestName.EndsWith('1'))
{
garage.Add(new Car("car123", "Red", 3, 3));
}
else if (TestContext.TestName.EndsWith('3'))
{
garage.Add(new Car("car123", "Red", 4, 3));
garage.Add(new Boat("boat123", "Red", 2, 3.1));
garage.Add(new Bus("bus123", "yellow", 8, 3));
}
}
public void AddTest()
{
//Arrange
var capatity1 = 1;
var capatity2 = 0;
var exepted1 = mockDataSource[Rnd.Next(0, mockDataSource.Count - 1)];
var exepted2 = mockDataSource[Rnd.Next(0, mockDataSource.Count - 1)];
while (exepted1.Eq(exepted2))
{
exepted2 = mockDataSource[Rnd.Next(0, mockDataSource.Count - 1)];
}
var garage1 = new Garage <Vehicle>(capatity1);
var garage2 = new Garage <Vehicle>(capatity2);
//act
var result1 = garage1.Add(exepted1);
var result2 = garage2.Add(exepted2);
Vehicle existsin1 = garage1.FirstOrDefault(v => v == exepted1);
Vehicle existsin2 = garage2.FirstOrDefault(v => v == exepted2);
//assert
Assert.IsTrue(result1, "Add Ok reported failure");
Assert.IsFalse(result2, "Add failed reported ok");
Assert.IsNotNull(existsin1, "Add ok element isn't in container");
Assert.IsNull(existsin2, "Add failed element is in container");
}
public void Garage_AddCarToCarGarage_Success()
{
Garage <Car> carGarage = new Garage <Car>(10);
Car car = new Car("ABC123", "Blue", 4, FuelType.Gasoline);
Assert.IsTrue(carGarage.Add(car));
}
public void Garage_Returnera_Vehicle_With_this_At_Wrong_Index_Test(int iIndex)
{
// Assert.Pass();
// Arrange
// expected
Guid guid = Guid.NewGuid();
Garage <ICanBeParkedInGarage> garage = new Garage <ICanBeParkedInGarage>(guid, "Garage 1", 5);
ICanBeParkedInGarage vehicle1 = new Car("AAA 111", "Röd", 4);
garage.Add(vehicle1);
// Act
// actual
// Assert
try
{
var vec = garage[iIndex];
Assert.Fail();
}
catch (ArgumentOutOfRangeException)
{
Assert.Pass();
}
}
public void Garage_AddCarToVehicleGarage_Success()
{
Garage <IVehicle> vehicleGarage = new Garage <IVehicle>(10);
Car car = new Car("ABC123", "Blue", 4, FuelType.Gasoline);
Assert.IsTrue(vehicleGarage.Add(car));
}
public void Garage_Add_Vehicle_Test()
{
// Assert.Pass();
// Arrange
// expected
Guid guid = Guid.NewGuid();
Garage <ICanBeParkedInGarage> garage = new Garage <ICanBeParkedInGarage>(guid, "Garage 1", 5);
ICanBeParkedInGarage vehicle = new Car("AAA 111", "RÖD", 4);
string strExpectedToString = $"Garage 1, Kapacitet: {5}, Antal parkerade fordon: {1}";
// Act
// actual
bool bAddedItem = garage.Add(vehicle);
int iActualNumberOfVehicles = garage.Count;
bool bActualIsEmpty = garage.IsEmpty;
bool bActualIsFull = garage.IsFull;
string strActualToString = garage.ToString();
// Assert
Assert.IsTrue(bAddedItem);
Assert.AreEqual(1, iActualNumberOfVehicles);
Assert.IsFalse(bActualIsEmpty);
Assert.IsFalse(bActualIsFull);
Assert.AreEqual(strExpectedToString, strActualToString);
}
/// <summary>
/// Metoden parkerar ett fordon i garaget
/// </summary>
/// <param name="vehicle">Fordonet som skall parkeras i garaget</param>
/// <returns>true om det gick parkera fordonet. Annars returneras false</returns>
/// <exception cref="System.ArgumentNullException">Kastas om referensen till vehicle är null</exception>
public bool ParkVehicle(ICanBeParkedInGarage vehicle)
{
if (vehicle == null)
{
throw new ArgumentNullException("ArgumentNullException. GarageHandler.ParkVehicle(ICanBeParkedInGarage vehicle). Referensen till vehicle är null");
}
var tmpVehicle = vehicle as IVehicle;
string strRegistrationNumber = tmpVehicle?.RegistrationNumber;
bool bParkedVehicle = false;
if (Garage.IsFull)
{
Ui.WriteLine($"Det går inte parkera fordon {vehicle.GetType().Name} med registreringsnummer {strRegistrationNumber}. {Garage.GarageName} är fullt");
}
else
{// Vi kan försöka att parkera fordonet
bParkedVehicle = Garage.Add(vehicle);
}
if (bParkedVehicle)
{// Vi har parkerat ett fordon. Skriv ut info om detta
Ui.WriteLine($"Parkerar fordon {vehicle.GetType().Name} med registreringsnummer {strRegistrationNumber}");
}
return(bParkedVehicle);
}
public void Enumerator()
{
// Arrange
int capacity = 10;
var vehicles = new TestVehicle[] {
new TestVehicle(),
new TestVehicle(),
new TestVehicle(),
new TestVehicle(),
};
var garage = new Garage <TestVehicle>(capacity);
foreach (var item in vehicles)
{
garage.Add(item);
}
// Act
var result = garage.ToList();
// Assert
// Using result.Count instead of vehicles.Length,
// to make sure we don't iterate over any null items
for (int i = 0; i < result.Count; i++)
{
Assert.AreSame(vehicles[i], result[i]);
}
Assert.AreEqual(vehicles.Length, result.Count);
}
public void Add_When_Not_Full()
{
// Arrange
int capacity = 4;
var garage = new Garage <TestVehicle>(capacity);
var vehicles = new TestVehicle[] {
new TestVehicle(),
new TestVehicle(),
new TestVehicle(),
new TestVehicle(),
};
// Act
foreach (var item in vehicles)
{
garage.Add(item);
}
// Assert
int i = 0;
foreach (var item in garage)
{
Assert.AreSame(vehicles[i++], item);
}
Assert.AreEqual(vehicles.Length, garage.Count);
Assert.AreEqual(vehicles.Length, i);
}
public void Garage_Remove_Vehicle_That_Not_Excist_Test()
{
// Assert.Pass();
// Arrange
// expected
Guid guid = Guid.NewGuid();
Garage <ICanBeParkedInGarage> garage = new Garage <ICanBeParkedInGarage>(guid, "Garage 1", 5);
ICanBeParkedInGarage vehicle1 = new Car("AAA 111", "Röd", 4);
ICanBeParkedInGarage vehicle2 = new Car("BBB 222", "Röd", 4);
ICanBeParkedInGarage vehicle3 = new Car("CCC 333", "Röd", 4);
string strExpectedToStringBeforeRemove = $"Garage 1, Kapacitet: {5}, Antal parkerade fordon: {2}";
string strExpectedToStringAfterRemove = $"Garage 1, Kapacitet: {5}, Antal parkerade fordon: {2}";
// Act
// actual
bool bActualAddedItem1 = garage.Add(vehicle1);
bool bActualAddedItem2 = garage.Add(vehicle2);
string strActualToStringBeforeRemove = garage.ToString();
int iActualNumberOfItemsBeforeRemove = garage.Count;
bool bActualRemovedItem3 = garage.Remove(vehicle3);
string strActualToStringAfterRemove = garage.ToString();
int iActualNumberOfItemsAfterRemove = garage.Count;
// Assert
Assert.IsTrue(bActualAddedItem1);
Assert.IsTrue(bActualAddedItem2);
Assert.AreEqual(strExpectedToStringBeforeRemove, strActualToStringBeforeRemove);
Assert.AreEqual(2, iActualNumberOfItemsBeforeRemove);
Assert.IsFalse(bActualRemovedItem3);
Assert.AreEqual(strExpectedToStringAfterRemove, strActualToStringAfterRemove);
Assert.AreEqual(2, iActualNumberOfItemsAfterRemove);
}
public void FindByRegistrationIDTest()
{
var garage = new Garage <Vehicle>(4);
var aCar = new Car("SKJ303", "blue", 5, 4, "BMW", "Petrol");
var aBus = new Bus("skd493", "white", 60, 6, "Scania", "City bus");
var aTruck = new Truck("aak594", "green", 3, 16, "Volvo", 2500);
var result1 = garage.FindByRegistrationID("skj303".ToUpper());
garage.Add(aCar);
garage.Add(aBus);
garage.Add(aTruck);
var result2 = garage.FindByRegistrationID("SkJ303".ToUpper());
Assert.AreEqual(null, result1);
Assert.AreEqual(aCar, result2);
}
public bool BuyACar(Car car, double price)
{
if (this.Money < price)
{
return(false);
}
if (!garage.Add(car))
{
garage.Extend(garage.Size + 1);
garage.Add(car);
Console.WriteLine(this.Money);
}
this.Money -= price;
return(true);
}
public void Add_When_Full()
{
// Arrange
int capacity = 1;
var garage = new Garage <TestVehicle>(capacity);
garage.Add(new TestVehicle());
// Act
bool success = garage.Add(new TestVehicle());
// Assert
Assert.AreEqual(false, success);
Assert.AreEqual(1, garage.Count);
// Just to make sure the iterator agrees
Assert.AreEqual(1, garage.Count());
}
public void Remove_Fail()
{
// Arrange
var garage = new Garage <TestVehicle>(4);
var car = new TestVehicle();
garage.Add(new TestVehicle());
garage.Add(new TestVehicle());
// Act
bool success = garage.Remove(car);
// Assert
Assert.IsFalse(success);
Assert.AreEqual(2, garage.Count);
Assert.AreEqual(2, garage.Count()); // Just to make sure the iterator agrees
}
public void DisplayAllTest()
{
var garage = new Garage <Vehicle>(4);
var aCar = new Car("SKJ303", "blue", 5, 4, "BMW", "Petrol");
var aBus = new Bus("skd493", "white", 60, 6, "Scania", "City bus");
var aTruck = new Truck("aak594", "green", 3, 16, "Volvo", 2500);
var success = $"{aBus.DisplayVehicleInformation()}\n{aCar.DisplayVehicleInformation()}\n{aTruck.DisplayVehicleInformation()}\n";
var result1 = garage.DisplayAll();
garage.Add(aCar);
garage.Add(aBus);
garage.Add(aTruck);
var result2 = garage.DisplayAll();
Assert.AreEqual(Garage <Vehicle> .garageEmpty, result1);
Assert.AreEqual(success, result2);
}
public Warehouse(string name) : base(name, 10, 10)
{
Vehicle s1 = Factories.VehicleFactory.CreateVehicle("Semi");
Vehicle s2 = Factories.VehicleFactory.CreateVehicle("Semi");
Vehicle s3 = Factories.VehicleFactory.CreateVehicle("Semi");
Garage.Add(s1);
Garage.Add(s2);
Garage.Add(s3);
}
