Hallo zusammen,
ich bing rad dabei Tests für sehr komplexe Fälle zu schreiben. Insgesammt werden pro test so um die 50 Attribute abgefragt. Ist ne fusselige Geschichte
So habe ich angefangen:
Pro test habe ich also eine Methode, die die Werte holt
und dann die Methode, die Daten vergleicht
.
die VergleichValues sind Werte die aus einem bereits transformierten Object geholt werden, ich prüfe nur, ob nach der Transformation bestimmte Werte, die sich nicht ändern dürfen, immer noch gleich sind. (Beispiel stark vereinfacht) Und es gibt wie gesagt so ca. 50 von solchen Werten.
So wie meine Tests jetzt aussehen, werden ja wirklich viele String angelegt:
Und dann kam der Gedanke: Das muss sich doch negativ auf Speicherplatz und Performance auswirken, oder?
Oder ist es bei der Anzahl der Attribute nicht relevant?
Die Tests könnten ja auch so aussehen:
ist vielleicht blöde Frage... aber ich merk grad dass mir etwas an Grundwissen fehlt ;(...
ich bing rad dabei Tests für sehr komplexe Fälle zu schreiben. Insgesammt werden pro test so um die 50 Attribute abgefragt. Ist ne fusselige Geschichte
So habe ich angefangen:
Java:
public MeinObjectTest{
String attr1;
String attr2;
String attr3;
String attr4;
String attr5;
Object object;
@Before
public void setUp(){
object = new Object(...);
}
@Test
public void test_FallEins(){
daten_Fuer_Fall_Eins_Vorbereiten();
tests_Fuer_Fall_Eins_durchfuehren();
}
@Test
public void test_FallZwei(){
daten_Fuer_Fall_Zwei_Vorbereiten();
tests_Fuer_Fall_Zwei_durchfuehren();
}
private void daten_Fuer_Fall_Eins_Vorbereiten(){
attr1 = object.getAttr1();
attr2 = object.getAttr2();
}
private void tests_Fuer_Fall_Eins_durchfuehren(){
vergleiche(vergleichValue1, attr1);
vergleiche(vergleichValue2, attr2);
}
private void daten_Fuer_Fall_Zwei_Vorbereiten(){
attr3 = object.getAttr3();
attr4 = object.getAttr4();
attr5 = object.getAttr5();
}
private void tests_Fuer_Fall_Zwei_durchfuehren(){
vergleiche(verlgiechValue3, attr3);
vergleiche(verlgiechValue4, attr4);
vergleiche(verlgiechValue5, attr5);
}
}
Pro test habe ich also eine Methode, die die Werte holt
Code:
private void daten_Fuer_Fall_XXX_Vorbereiten()
Code:
private void tests_Fuer_Fall_XXX_durchfuehren()
die VergleichValues sind Werte die aus einem bereits transformierten Object geholt werden, ich prüfe nur, ob nach der Transformation bestimmte Werte, die sich nicht ändern dürfen, immer noch gleich sind. (Beispiel stark vereinfacht) Und es gibt wie gesagt so ca. 50 von solchen Werten.
So wie meine Tests jetzt aussehen, werden ja wirklich viele String angelegt:
Java:
public MeinObjectTest{
String attr1;
String attr2;
String attr3;
String attr4;
String attr5;
...
String attr50;
}
Und dann kam der Gedanke: Das muss sich doch negativ auf Speicherplatz und Performance auswirken, oder?
Oder ist es bei der Anzahl der Attribute nicht relevant?
Die Tests könnten ja auch so aussehen:
Java:
public MeinObjectTest{
Object object;
@Before
public void setUp(){
object = new Object(...);
}
@Test
public void test_FallEins(){
vergleiche(vergleichValue1, object.getAttr1());
vergleiche(vergleichValue2, object.getAttr2());
}
@Test
public void test_FallZwei(){
vergleiche(verlgiechValue3, object.getAttr3());
vergleiche(verlgiechValue4, object.getAttr4());
vergleiche(verlgiechValue5, object.getAttr5());
}
}
ist vielleicht blöde Frage... aber ich merk grad dass mir etwas an Grundwissen fehlt ;(...