Hash-Maps / ArrayLists testen

[Java-Problems]

Hallo zusammen,
kurze Frage bezüglich JUnittesting:
Wie kann ich HashMaps / ArrayLists mit JUnit testen???

 

[Java-Problems]

Keiner da, der mir helfen kann?
Wäre wichtig!

 

[mvitz]

Wie meinst du das?
Eigentlich kann man sich bei den Komponenten darauf verlassen, dass sie funktionieren.

Aber als Beispiel ginge das:
[HIGHLIGHT="Java"]import java.util.HashMap;

import static junit.framework.Assert.*;
import org.junit.BeforeClass;
import org.junit.Test;

public class TestHashMap {

private static HashMap<Integer, String> theMap;

@BeforeClass
public static void beforeClass() {
theMap = new HashMap<Integer, String>();
}

@Test
public void testPut() {
theMap.put(1, "Test");
assertEquals("One element should be in the map.", 1, theMap.size());
assertEquals("The added element should be added.", "Test", theMap
.get(1));
}
}[/HIGHLIGHT]

 

[Java-Problems]

Ja ich habe das Problem dass ich eine Klasse Test habe und die Orginalklasse. Die Orginalklasse erzeugt allerdings im Konstruktor eine Hash-Map einer anderen Objektsorte (andere Klasse).
Damit ich nun aber den Test erfolgreich durchführen muss, benötige ich ja dann auch noch die Hash-Map.
Verstehst du mein Problem? Das ganze Projekt ist dermasen verschatelt, dass ich nicht nur eine Klasse für sich alleine testen kann. So ist aber die Aufgabenstellung, die es zu erfüllen gilt!

 

[mvitz]

Quellcode der Klasse die du testen möchtest würde das ganze vereinfachen!

Vorher kann ich dir nichts genaueres sagen, evtl. musst du auch so genannte Mock Objekte bauen, dafür kann man z.B. Frameworks wie EasyMock oder JMock nutzen, aber ohne Code gesehen zu haben kann ich nichts genaues sagen, da ich nicht wirklich verstehe wo dein Problem ist.

 

[Java-Problems]

public class Recipe {

	private String name;
	public int neededIng;
	public int quantityNec;
	public String ingNa;
	private List<RecipeIngredient> recipeIngredient;

	public void createRecipeAskingUser() {
		this.name = IOTools.readLine("Name of the recipe: ");
		this.neededIng = IOTools
				.readInt("How many different ingredients are necessary? ");
	}

	public Recipe() {
		createRecipeAskingUser();
		this.recipeIngredient = new ArrayList<RecipeIngredient>();

	}

	public int getNeededIng() {
		return neededIng;
	}

	public void addIngredient(RecipeIngredient recipeIngredient) {
		this.recipeIngredient.add(recipeIngredient);
	}

	public String getName() {
		return this.name;
	}


	public int[] getQuantNec() {
		int[] getQuantNec = new int[getIngredientsSize()];
		for (int i = 0; i < getIngredientsSize(); i++)
			getQuantNec[i] = this.recipeIngredient.get(i).getQuantityNec();

		return getQuantNec;
	}
	
	
	public int getIngredientsSize() {
		return this.recipeIngredient.size();

	}

	public void print() {
		System.out.println("Recipe: " + getName());
		for (int i = 0; i < neededIng; i++) {
			System.out.println(recipeIngredient.get(i).getIngredient()
					.getName()
					+ " ["
					+ recipeIngredient.get(i).getQuantityNec()
					+ "]--> alcoholic?:"
					+ recipeIngredient.get(i).getIngredient().isAlcoholic());
		}

	}

}

Das ist ziemlich verschachtelt alles
Und ich weiß nicht wie ich z.Bsp. für die Methode getQuantNec ein Unittest schreiben kann...

 

[0x7F800000]

Erstellst ein rezept, packst da hundert zufällige ingredients rein, rufst die methode auf, guggst dass das zurückgegebene Array die erwartete Länge hat, und alle Zahlen in richtiger Anzahl enthält?... Was soll man denn da großartig testen, diese methoden tun bisher praktisch nichts

 

[mvitz]

Du müsste mir zumindest noch die Klassen:
- RecipeIngredient
und vermutlich noch
- Ingredient
geben

Habe gerade nicht die Lust mir da Dummyklassen zu zu schreiben, die dann evtl ganz anders als deine sind.

Was ich bisher anmerken möchte ist, dass die Methode
[HIGHLIGHT="Java"]public void createRecipeAskingUser() {
this.name = IOTools.readLine("Name of the recipe: ");
this.neededIng = IOTools
.readInt("How many different ingredients are necessary? ");
}
[/HIGHLIGHT]

meiner Meinung nach in dieser Klasse nichts zu suchen hat. Man sollte User Eingaben von den Daten trennen, was du heir eindeutig nicht tust.

Edit:
Andrey hat dir auch das allgemeine vorgehen aufgezeigt ^^

 

[Java-Problems]

ja das werde ich noch berücksichtigen und noch in eine separate Klasse miteinbauen!
Danke für den Tipp!

public class RecipeIngredient {

	private int quantityNec;
	private Ingredient ing;

	/**
	 * @return
	 */
	public int getQuantityNec() {
		return quantityNec;
	}

	/**
	 * @param quantityNec
	 */
	public void setQuantityNec(int quantityNec) {
		this.quantityNec = quantityNec;
	}

	/**
	 * @param ingredient
	 * @param quantityNec
	 */
	public void ingredient(Ingredient ingredient, int quantityNec) {
		this.ing = ingredient;
		setQuantityNec(quantityNec);
	}

	/**
	 * @return ing
	 */
	public Ingredient getIngredient() {
		return ing;
	}

}

public abstract class Ingredient {

	private String name;
	private int quantityAv;
	private int quantityNec;
	boolean alcoholic;

	public String getName() {
		return name;
	}

	public int getQuantityAv() {
		return quantityAv;
	}

	public boolean isAlcoholic() {
		return alcoholic;
	}

	public void setAlcoholic(boolean alcoholic) {
		this.alcoholic = alcoholic;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void setQuantityAv(int quantityAv) {
		this.quantityAv = quantityAv;
	}

	@Override
	public String toString() {
		return this.getName() + " [" + this.getQuantityAv() + "]"
				+ " alcoloic: " + isAlcoholic();
	}

}

 

[0x7F800000]

meiner Meinung nach in dieser Klasse nichts zu suchen hat. Man sollte User Eingaben von den Daten trennen, was du heir eindeutig nicht tust.

und sowas abartiges wie diese "print()"-methode sollte auch schleunigst aus dem code weginsektiziert werden. Wozu soll so etwas gut sein? Die ist i.Allg. nicht verwendbar und wirft die Ausgaben per Zufall irgendwohin, wohin das System.out. grad zeigt. Tausend millionen Buffer zu basteln und den Standardausgabestrom jedes mal umzubiegen, nur um deine Klasse irgendwo außer als auf der Standardkonsole auszugeben: das ist bekloppt das tut kein gesunder Mensch. Deswegen wird ja auch eine ordentliche toString()-methode vorgeschrieben.

 

[mvitz]

Ich habe das ganze mal etwas umgeschrieben ^^. Wenn du deine Klassen so lassen möchtest, musst du halt mein Beispiel an dich anpassen. Deine aktuellen Klassen finde ich total unübersichtlich und irgendwie auch unlogisch...

Also jetzt meine:

Klasse Recipe stellt ein Rezept dar, es hat einen Namen und Rezeptzutaten.
[HIGHLIGHT="Java"]import java.util.LinkedList;
import java.util.List;

public class Recipe {

private String name;
private List<RecipeIngredient> ingredients;

public Recipe(String aName) {
name = aName;
ingredients = new LinkedList<RecipeIngredient>();

}

public void addIngredient(RecipeIngredient aIngredient) {
ingredients.add(aIngredient);
}

public int getNumberOfIngredients() {
return ingredients.size();
}

public int[] getNumberOfNeededIngredientQuantities() {
int[] quantities = new int[ingredients.size()];
for (int i = 0; i < ingredients.size(); i++) {
RecipeIngredient theIngredient = ingredients.get(i);
quantities = theIngredient.getNeededQuantity();
}
return quantities;
}

@Override
public String toString() {
StringBuffer theStringBuffer = new StringBuffer();
theStringBuffer.append("Recpipe: " + name + "\n");
for (RecipeIngredient eachIngredient : ingredients) {
theStringBuffer.append("\t" + eachIngredient + "\n");
}
return theStringBuffer.toString();
}
}[/HIGHLIGHT]

Eine Rezeptzutat besteht aus einer Zutat und einer benötigten Menge:
[HIGHLIGHT="Java"]public class RecipeIngredient {

private int neededQuantity;
private Ingredient ingredient;

public RecipeIngredient(Ingredient aIngredient, int aNeededQuantity) {
ingredient = aIngredient;
neededQuantity = aNeededQuantity;
}

public int getNeededQuantity() {
return neededQuantity;
}

public void setNeededQuantity(int neededQuantity) {
this.neededQuantity = neededQuantity;
}

public Ingredient getIngredient() {
return ingredient;
}

public void setIngredient(Ingredient ingredient) {
this.ingredient = ingredient;
}

@Override
public String toString() {
return ingredient + " [" + neededQuantity + "]";
}
}[/HIGHLIGHT]

Eine Zutat wiederrum hat einen Namen, eine aktuell vorhandene Menge und kann alkoholisch sein:
[HIGHLIGHT="Java"]public class Ingredient {

private String name;
private int quantity;
boolean alcoholic;

public Ingredient(String aName, int aQuantity, boolean isAlcoholic) {
name = aName;
quantity = aQuantity;
alcoholic = isAlcoholic;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getQuantity() {
return quantity;
}

public void setQuantity(int quantity) {
this.quantity = quantity;
}

public boolean isAlcoholic() {
return alcoholic;
}

public void setAlcoholic(boolean alcoholic) {
this.alcoholic = alcoholic;
}

@Override
public String toString() {
return name + " [" + quantity + "]" + " alcoloic: " + alcoholic;
}
}[/HIGHLIGHT]

Und zum Schluss der Test:
[HIGHLIGHT="Java"]import static junit.framework.Assert.assertEquals;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class RecipeTest {

private static Recipe recipe;

@Before
public void beforeEachTest() {
recipe = new Recipe("Testrezept.");
}

@After
public void afterEachTest() {
recipe = null;
}

@Test
public void getNumberOfNeededIngredientQuantities() {
RecipeIngredient test1 = createRecipeIngredient("test1", 10, false, 2);
RecipeIngredient test2 = createRecipeIngredient("test2", 10, true, 5);
recipe.addIngredient(test1);
recipe.addIngredient(test2);
int[] theExpectedResult = { 2, 5 };
int[] theActualResult = recipe.getNumberOfNeededIngredientQuantities();
assertEquals("Two ingredients should be added.",
theExpectedResult.length, theActualResult.length);
for (int i = 0; i < theExpectedResult.length; i++) {
String theMessage = "The ingredients needed quantity should be "
+ theExpectedResult + ".";
assertEquals(theMessage, theActualResult, theExpectedResult);
}
}

private static RecipeIngredient createRecipeIngredient(String aName,
int aQuantity, boolean isAlcoholic, int aNeededQuantity) {
Ingredient theIngredient = new Ingredient(aName, aQuantity, isAlcoholic);
RecipeIngredient theRecipeIngredient = new RecipeIngredient(
theIngredient, aNeededQuantity);
return theRecipeIngredient;
}
}[/HIGHLIGHT]

Sind noch zwei unschöne Sachen drin.
A) Die Ausgabe der benötigten Mengen als int[]. Ich bin mir nicht sicher ob eine foreach-Schleife immer dieselbe Reihenfolge garantiert deswegen die Zugriffe über den index. Einfach wäre es sicher etwas anderes zurückzugeben, nur was?

B) Die Klasse RecipeIngredient gefällt mir nicht. Aber habe atm keine Lust mir dazu was anderes auszudenken, evtl. schlägt ja wer anderes was vor.

 

[Java-Problems]

okay
danke dir schonmal für deine mühe!

 

[0x7F800000]

A) Die Ausgabe der benötigten Mengen als int[]. Ich bin mir nicht sicher ob eine foreach-Schleife immer dieselbe Reihenfolge garantiert deswegen die Zugriffe über den index.

Bei lists wird die normale reihenfolge garantiert. Bei Sets sollte man aber aufpassen, da wird eh alles irgendwie bunt durcheinandergemischt. Aber da es ja ein List ist, ist es ok.