Hallo, wie in der Aufgabenbeschreibung soll ich ein Programm für einen Kfz-Händler erstellen und mit einem vorgegebenem JUnit-Test überprüfen. Der zeigt aber noch 3 Errors an, doch ich weiß nicht was sie genau bedeuten.
Daher zu meiner Frage, habe ich die Aufgabe überhaupt richtig verstanden und stimmt was ich gemacht habe in etwa? In Eclipse kommen soweit keine Fehlermeldungen.
"
Der KFZ-Händler hat Platz für 15 PKWs (Konstante VehicleType.PASSENGER_CAR) und 5 LKWs (VehicleType.TRUCK) und eine Tankstelle, deren Kapazität 250 Liter Diesel sowie 180 Liter Benzin beträgt.
Jeder PKW muss für einen erfolgreichen Verkauf mit 40 Litern Benzin betankt werden können und jeder LKW mit 80 Liter Diesel.
Funktionalität: sellVehicle: Verkauf einer Vehicle-Instanz mit Typ-definierendem Parameter byte vehicleType, falls möglich (richtiger Typus ist noch lagernd und genügend Treibstoff vorhanden)
sellVehicles: Verkauf mehrerer Vehicles mit demselben Typus byte vehicleType und einer ganzzahligen Stückzahl (int)
fillGas: Auffüllen der Tankstelle um float liters Benzin
fillDiesel: Auffüllen der Tankstelle um float liters Diesel
reorderVehicles: Das Lager wieder neu befüllen um n Vehicles eines Typus byte vehicleType. Hinweise: Zu Beginn sind die Lager (private Felder float gasStockLiters, float dieselStockLiters, int passengerCarsStock, int trucksStock ) des KFZ-Händlers immer voll. Das Auffüllen von Lagerständen funktioniert (Rückgabetyp boolean) nur mit der richtigen Menge oder Anzahl, sodass die maximale Lagerkapazität nicht überschritten wird. Der Typ des KFZs ist durch die byte-Konstanten der (vorgegebenen) Klasse VehicleType definiert. Nutzen sie diese Konstanten (nicht die Absolutwerte der Konstanten!) und überprüfen sie diese auch, wo angebracht. Die lagernden Vehicles sind nur als Zähler mitzuspeichern. Wird aber ein Fahrzeug (bzw. mehrere) verkauft, dann soll als Methoden-Rückgabewert ein Objekt der Klasse Vehicle mit dem richtigen Treibstofffüllstand (Feld fuel) und Typus (Feld vehicleType) zurückgegeben werden.
Mögliche Lösung:
JUnit Test:
Daher zu meiner Frage, habe ich die Aufgabe überhaupt richtig verstanden und stimmt was ich gemacht habe in etwa? In Eclipse kommen soweit keine Fehlermeldungen.
"
Der KFZ-Händler hat Platz für 15 PKWs (Konstante VehicleType.PASSENGER_CAR) und 5 LKWs (VehicleType.TRUCK) und eine Tankstelle, deren Kapazität 250 Liter Diesel sowie 180 Liter Benzin beträgt.
Jeder PKW muss für einen erfolgreichen Verkauf mit 40 Litern Benzin betankt werden können und jeder LKW mit 80 Liter Diesel.
Funktionalität: sellVehicle: Verkauf einer Vehicle-Instanz mit Typ-definierendem Parameter byte vehicleType, falls möglich (richtiger Typus ist noch lagernd und genügend Treibstoff vorhanden)
sellVehicles: Verkauf mehrerer Vehicles mit demselben Typus byte vehicleType und einer ganzzahligen Stückzahl (int)
fillGas: Auffüllen der Tankstelle um float liters Benzin
fillDiesel: Auffüllen der Tankstelle um float liters Diesel
reorderVehicles: Das Lager wieder neu befüllen um n Vehicles eines Typus byte vehicleType. Hinweise: Zu Beginn sind die Lager (private Felder float gasStockLiters, float dieselStockLiters, int passengerCarsStock, int trucksStock ) des KFZ-Händlers immer voll. Das Auffüllen von Lagerständen funktioniert (Rückgabetyp boolean) nur mit der richtigen Menge oder Anzahl, sodass die maximale Lagerkapazität nicht überschritten wird. Der Typ des KFZs ist durch die byte-Konstanten der (vorgegebenen) Klasse VehicleType definiert. Nutzen sie diese Konstanten (nicht die Absolutwerte der Konstanten!) und überprüfen sie diese auch, wo angebracht. Die lagernden Vehicles sind nur als Zähler mitzuspeichern. Wird aber ein Fahrzeug (bzw. mehrere) verkauft, dann soll als Methoden-Rückgabewert ein Objekt der Klasse Vehicle mit dem richtigen Treibstofffüllstand (Feld fuel) und Typus (Feld vehicleType) zurückgegeben werden.
Mögliche Lösung:
Code:
public class CarTrader {
public static final float CAPACITY_DIESEL_LITERS = 250.f;
public static final float CAPACITY_GAS_LITERS = 180.f;
public static final int CAPACITY_PASSENGER_CARS = 15;
public static final int CAPACITY_TRUCKS = 5;
float gasStockLiters=250.f;
float dieselStockLiters=180.f;
int passengerCarsStock=15;
int trucksStock=5;
void setGasStockLiters(float gasStockLiters){
this.gasStockLiters=gasStockLiters;
}
void setDieselStockLiters(float dieselStockLiters){
this.dieselStockLiters=dieselStockLiters;
}
void setPassengerCarsStock(int passengerCarsStock){
this.passengerCarsStock=passengerCarsStock;
}
void setTrucksStock(int trucksStock){
this.trucksStock=trucksStock;
}
int getPassengerCarsStock(){
return passengerCarsStock;
}
int getTrucksStock(){
return trucksStock;
}
float getGasStockLiters(){
return gasStockLiters;
}
float getDieselStockLiters(){
return dieselStockLiters;
}
public Vehicle sellVehicle(byte vehicleType){
Vehicle soldVehicle=null;
switch (vehicleType){
case VehicleType.TRUCK:
if(this.dieselStockLiters>=Vehicle.TANK_SIZE_TRUCK && this.trucksStock>=1){
trucksStock = trucksStock - 1;
dieselStockLiters = dieselStockLiters - Vehicle.TANK_SIZE_PASSENGER_CAR;
soldVehicle = new Vehicle(VehicleType.TRUCK, Vehicle.TANK_SIZE_TRUCK);
System.out.println("LKW erfolgreich verkauft");
}
else{
soldVehicle=null;
}
break;
case VehicleType.PASSENGER_CAR:
if(gasStockLiters>=Vehicle.TANK_SIZE_PASSENGER_CAR && this.passengerCarsStock>=1){
passengerCarsStock = passengerCarsStock - 1;
gasStockLiters = gasStockLiters - Vehicle.TANK_SIZE_PASSENGER_CAR;
soldVehicle = new Vehicle(VehicleType.PASSENGER_CAR, Vehicle.TANK_SIZE_PASSENGER_CAR);
System.out.println("PKW erfolgreich verkauft");
}
else{
soldVehicle=null;
}
break;
default:
break;
}
return soldVehicle;
}
public Vehicle[] sellVehicles(byte vehicleType, int amount){
Vehicle[] soldVehicles = new Vehicle[amount];
switch (vehicleType){
case VehicleType.TRUCK:
if(this.dieselStockLiters>=Vehicle.TANK_SIZE_TRUCK && this.trucksStock>=amount){
trucksStock = trucksStock - amount;
dieselStockLiters = dieselStockLiters - (Vehicle.TANK_SIZE_TRUCK * amount);
for (int i=0; i<amount; i++){
soldVehicles[i]=new Vehicle(VehicleType.PASSENGER_CAR, Vehicle.TANK_SIZE_PASSENGER_CAR);
}
System.out.println("LKW erfolgreich verkauft");
}
else{
soldVehicles=null;
}
break;
case VehicleType.PASSENGER_CAR:
if(gasStockLiters>=Vehicle.TANK_SIZE_PASSENGER_CAR && this.passengerCarsStock>=amount){
passengerCarsStock = passengerCarsStock - amount;
gasStockLiters = gasStockLiters - (Vehicle.TANK_SIZE_TRUCK * amount);
for (int i=0; i<amount; i++){
soldVehicles[i]=new Vehicle(VehicleType.PASSENGER_CAR, Vehicle.TANK_SIZE_PASSENGER_CAR);
}
System.out.println("PKW erfolgreich verkauft");
}
else{
soldVehicles=null;
}
break;
default:
soldVehicles=null;
break;
}
return soldVehicles;
}
void fillGas(float gas){
if((gasStockLiters + gas)<=250){
gasStockLiters = gasStockLiters + gas;
}
else{
System.err.println("Die Kapazität beträgt höchstens 250 Liter");
}
}
void fillDiesel(float diesel){
if((dieselStockLiters + diesel)<=180){
dieselStockLiters = dieselStockLiters + diesel;
}
else{
System.err.println("Die Kapazität beträgt höchstens 180 Liter");
}
}
public boolean reorderVehicles(int vehicle, int amountVehicles){
boolean full=false;
if (vehicle==VehicleType.TRUCK){
if ((trucksStock + amountVehicles)<=5){
trucksStock = trucksStock + amountVehicles;
full=true;
}
}
if (vehicle==VehicleType.PASSENGER_CAR){
if ((passengerCarsStock + amountVehicles)<=15){
passengerCarsStock = passengerCarsStock + amountVehicles;
full=true;
}
}
else {
System.out.println("Bitte 5 oder 7 wählen");
}
return full;
}
void statusOutput()
{
System.out.println("AutoHändler - Lagerbestand:");
System.out.println(" PKW: " + passengerCarsStock);
System.out.println(" - Benzin: " + gasStockLiters);
System.out.println(" LKW: " + trucksStock);
System.out.println(" - Diesel: " + dieselStockLiters);
}
Code:
public final class VehicleType {
public static final byte PASSENGER_CAR = 7;
public static final byte TRUCK = 5;
/**
* This class is just an organizer for the above constants; Not instantiable.
*/
private VehicleType(){
}
}
Code:
public class Vehicle {
public static final float TANK_SIZE_PASSENGER_CAR = 40.f;
public static final float TANK_SIZE_TRUCK = 80.f;
public float fuel;
public byte VehicleType;
public Vehicle(byte VehicleType, float fuel){
this.VehicleType= VehicleType;
this.fuel= fuel;
}
}
JUnit Test:
Code:
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;
/**
* Einführung in die Softwareentwicklung 2 (ESE2), SS2018
* Vorführaufgabe 1
* <p>
* JUnit Tests
*
* @author Clemens Schartmüller, Technische Hochschule Ingolstadt (THI)
* @version 18.03.2018
* @email clemens.schartmueller@thi.de
*/
public class CarTraderJUnitTests {
private static final double DELTA_FLOAT = 0.0000001f;
CarTrader trader;
@Before
public void setUp() throws Exception {
trader = new CarTrader();
}
@After
public void tearDown() throws Exception {
trader = null;
}
@Test
public void testUnchangedConstants() {
assertEquals(7, VehicleType.PASSENGER_CAR);
assertEquals(5, VehicleType.TRUCK);
assertEquals(250.f, CarTrader.CAPACITY_DIESEL_LITERS, DELTA_FLOAT);
assertEquals(180.f, CarTrader.CAPACITY_GAS_LITERS, DELTA_FLOAT);
assertEquals(15, CarTrader.CAPACITY_PASSENGER_CARS);
assertEquals(5, CarTrader.CAPACITY_TRUCKS);
assertEquals(40.f, Vehicle.TANK_SIZE_PASSENGER_CAR, DELTA_FLOAT);
assertEquals(80.f, Vehicle.TANK_SIZE_TRUCK, DELTA_FLOAT);
}
@Test
public void testInitialStock() {
assertEquals(CarTrader.CAPACITY_PASSENGER_CARS, trader.getPassengerCarsStock());
assertEquals(CarTrader.CAPACITY_TRUCKS, trader.getTrucksStock());
assertEquals(CarTrader.CAPACITY_GAS_LITERS, trader.getGasStockLiters(), DELTA_FLOAT);
assertEquals(CarTrader.CAPACITY_DIESEL_LITERS, trader.getDieselStockLiters(), DELTA_FLOAT);
}
@Test
public void testSoldCarAttributes() {
testSoldCarAttributes(VehicleType.PASSENGER_CAR, trader.sellVehicle(VehicleType.PASSENGER_CAR));
testSoldCarAttributes(VehicleType.TRUCK, trader.sellVehicle(VehicleType.TRUCK));
}
@Test
public void testTruckStocks() {
for (int i = 0; i < 3; i++) {
assertNotNull("A fresh trader needs to be able to sell 3 trucks (3*80 < 250l) without refill", trader.sellVehicle(VehicleType.TRUCK));
}
refillFuelAndCheckVehicleStock(VehicleType.TRUCK, 3);
trader = new CarTrader();
Vehicle[] multibuy = trader.sellVehicles(VehicleType.TRUCK, 3);
assertEquals("A fresh trader needs to be able to sell 3 trucks (3*80 < 250l) without refill", 3, multibuy.length);
assertNotNull("A fresh trader needs to be able to sell 3 trucks (3*80 < 250l) without refill", multibuy);
for (Vehicle v : multibuy) {
assertNotNull("A fresh trader needs to be able to sell 3 trucks (3*80 < 250l) without refill", v);
testSoldCarAttributes(VehicleType.TRUCK, v);
}
refillFuelAndCheckVehicleStock(VehicleType.TRUCK, 3);
}
@Test
public void testReorderVehiclesAboveCap() {
assertFalse(trader.reorderVehicles(VehicleType.PASSENGER_CAR, 1));
assertEquals(CarTrader.CAPACITY_PASSENGER_CARS, trader.getPassengerCarsStock());
assertFalse(trader.reorderVehicles(VehicleType.TRUCK, 1));
assertEquals(CarTrader.CAPACITY_TRUCKS, trader.getTrucksStock());
}
@Test
public void testMixedBuy() {
assertNotNull(trader.sellVehicles(VehicleType.TRUCK, 2));
assertNotNull(trader.sellVehicles(VehicleType.PASSENGER_CAR, 1));
assertEquals(CarTrader.CAPACITY_DIESEL_LITERS - 2 * Vehicle.TANK_SIZE_TRUCK, trader.getDieselStockLiters(), DELTA_FLOAT);
assertEquals(CarTrader.CAPACITY_GAS_LITERS - 1 * Vehicle.TANK_SIZE_PASSENGER_CAR, trader.getGasStockLiters(), DELTA_FLOAT);
}
@Test
public void testRestockingPassengerCar() {
for (int i = 0; i < 3; i++) {
assertNotNull(trader.sellVehicles(VehicleType.PASSENGER_CAR, 4));
assertTrue(trader.fillGas(Vehicle.TANK_SIZE_PASSENGER_CAR * 4));
}
assertNotNull(trader.sellVehicles(VehicleType.PASSENGER_CAR, 3));
assertTrue(trader.fillGas(Vehicle.TANK_SIZE_PASSENGER_CAR * 3));
assertNull("Trader should not be able to sell more than 15 passenger cars without restocking", trader.sellVehicles(VehicleType.PASSENGER_CAR, 3));
assertTrue(trader.reorderVehicles(VehicleType.PASSENGER_CAR, 3));
assertNull("Trader should not be able to sell more than the restocked amount of cars (3) after being totally depleted and restock again.", trader.sellVehicles(VehicleType.PASSENGER_CAR, 4));
assertFalse("Trader should not be able to restock more cars than the max stock capacity.", trader.reorderVehicles(VehicleType.PASSENGER_CAR, CarTrader.CAPACITY_PASSENGER_CARS - 3 + 1));
}
@Test
public void testRestockingTrucks() {
assertNotNull(trader.sellVehicles(VehicleType.TRUCK, 3));
assertTrue(trader.fillDiesel(Vehicle.TANK_SIZE_TRUCK * 3));
assertNotNull(trader.sellVehicles(VehicleType.TRUCK, 2)); // trader should be empty now, but enough diesel left to sell more
assertTrue(trader.fillDiesel(Vehicle.TANK_SIZE_TRUCK * 2));
assertNull("Trader should not be able to sell more than 5 trucks without restocking", trader.sellVehicles(VehicleType.TRUCK, 3));
assertTrue(trader.reorderVehicles(VehicleType.TRUCK, 2));
assertNull("Trader should not be able to sell more than the restocked amount of cars (2) after being totally depleted and restock again.", trader.sellVehicles(VehicleType.TRUCK, 3));
assertFalse("Trader should not be able to restock more cars than the max stock capacity.", trader.reorderVehicles(VehicleType.TRUCK, CarTrader.CAPACITY_TRUCKS - 2 + 1));
}
@Test
public void testPassengerCarStocks() {
for (int i = 0; i < 4; i++) {
assertNotNull("A fresh trader needs to be able to sell 4 passenger cars (4*40 < 180l) without refill", trader.sellVehicle(VehicleType.PASSENGER_CAR));
}
refillFuelAndCheckVehicleStock(VehicleType.PASSENGER_CAR, 4);
trader = new CarTrader();
Vehicle[] multibuy = trader.sellVehicles(VehicleType.PASSENGER_CAR, 4);
assertEquals("A fresh trader needs to be able to sell 4 passenger cars (4*40 < 180l) without refill", 4, multibuy.length);
assertNotNull("A fresh trader needs to be able to sell 4 passenger cars (4*40 < 180l) without refill", multibuy);
for (Vehicle v : multibuy) {
assertNotNull("A fresh trader needs to be able to sell 4 passenger cars (4*40 < 180l) without refill", v);
testSoldCarAttributes(VehicleType.PASSENGER_CAR, v);
}
refillFuelAndCheckVehicleStock(VehicleType.PASSENGER_CAR, 4);
}
private void refillFuelAndCheckVehicleStock(byte vehicleType, int unitsSold) {
float newFuelStock = getFuelStockCap(vehicleType) - unitsSold * getFuelByType(vehicleType);
if (vehicleType == VehicleType.PASSENGER_CAR) {
assertEquals(newFuelStock, trader.getGasStockLiters(), DELTA_FLOAT);
assertTrue("Overfilling the gas stock should not be allowed, i.e., return false", !trader.fillGas((CarTrader.CAPACITY_GAS_LITERS - newFuelStock) * 3));
assertTrue(trader.fillGas(CarTrader.CAPACITY_GAS_LITERS - newFuelStock - 10.f));
assertEquals(CarTrader.CAPACITY_GAS_LITERS - 10.f, trader.getGasStockLiters(), DELTA_FLOAT);
assertTrue("Filling the stock exactly to its capacity should be allowed (i.e., return true)", trader.fillGas(10.f));
// buy cars in batches of 4 & refill until stock is empty
for (int i = 0; i < 2; i++) {
Vehicle[] vehicles = trader.sellVehicles(VehicleType.PASSENGER_CAR, 4);
assertEquals(4, vehicles.length);
assertTrue(trader.fillGas(Vehicle.TANK_SIZE_PASSENGER_CAR * 4));
}
// now we should have 12 cars sold, need 3 more until it should be disallowed
assertNotNull(trader.sellVehicles(VehicleType.PASSENGER_CAR, 3));
assertTrue(trader.fillGas(Vehicle.TANK_SIZE_PASSENGER_CAR * 3));
assertNull("Should not be able to buy more than 15 cars total without refill, although gas stock would allow it", trader.sellVehicles(VehicleType.PASSENGER_CAR, 4));
} else if (vehicleType == VehicleType.TRUCK) {
assertEquals(newFuelStock, trader.getDieselStockLiters(), DELTA_FLOAT);
assertEquals("Overfilling the diesel stock should not be allowed, i.e., return false", false, trader.fillDiesel((CarTrader.CAPACITY_DIESEL_LITERS - newFuelStock) * 3));
assertTrue(trader.fillDiesel(CarTrader.CAPACITY_DIESEL_LITERS - newFuelStock - 10.f));
assertEquals(CarTrader.CAPACITY_DIESEL_LITERS - 10.f, trader.getDieselStockLiters(), DELTA_FLOAT);
assertTrue("Filling the stock exactly to its capacity should be allowed (i.e., return true)", trader.fillDiesel(10.f));
// diesel is refilled, we should be able to buy another 2 trucks, but not more
for (int i = 0; i < 2; i++) {
testSoldCarAttributes(VehicleType.TRUCK, trader.sellVehicle(VehicleType.TRUCK));
}
// next should fail
assertNull("You should not be able to buy more than 5 trucks without refilling the stock", trader.sellVehicle(VehicleType.TRUCK));
}
}
private float getFuelByType(byte vehicleType) {
switch (vehicleType) {
case VehicleType.PASSENGER_CAR:
return Vehicle.TANK_SIZE_PASSENGER_CAR;
case VehicleType.TRUCK:
return Vehicle.TANK_SIZE_TRUCK;
default:
throw new IllegalArgumentException();
}
}
private float getFuelStockCap(byte vehicleType) {
switch (vehicleType) {
case VehicleType.PASSENGER_CAR:
return CarTrader.CAPACITY_GAS_LITERS;
case VehicleType.TRUCK:
return CarTrader.CAPACITY_DIESEL_LITERS;
default:
throw new IllegalArgumentException();
}
}
private void testSoldCarAttributes(byte vehicleType, final Vehicle v) {
switch (vehicleType) {
case VehicleType.PASSENGER_CAR:
assertEquals(40.f, v.getFuel(), DELTA_FLOAT);
assertEquals(VehicleType.PASSENGER_CAR, v.getVehicleType());
break;
case VehicleType.TRUCK:
assertEquals(80.f, v.getFuel(), DELTA_FLOAT);
assertEquals(VehicleType.TRUCK, v.getVehicleType());
}
}
}