Performance/Speicherplatz-Nutzung bei Tests

[Alenka87]

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:

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

private void daten_Fuer_Fall_XXX_Vorbereiten()

und dann die Methode, die Daten vergleicht

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:

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:

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 😳;(...

 

[Alenka87]

Was ich noch hinzufügen wollte/sollte:
bei der Idee, die Test-Methode auf zwei einzelne zu splitten - 1)vorbereiten und 2)durchführen - habe ich an CleanCode (Regel: pro Methode nur eine Abstraktionsebene) gedacht

 

[DerSchokoBär]

Wie fragst du denn die Attribute ab, per Reflection?

 

[Alenka87]

mit Getter()-Methoden meines Objekts

 

[maki]

Und dann kam der Gedanke: Das muss sich doch negativ auf Speicherplatz und Performance auswirken, oder?

Solche Gedanken solltest du ignorieren solabnge du keine Probleme mit der Performance hast.

bei der Idee, die Test-Methode auf zwei einzelne zu splitten - 1)vorbereiten und 2)durchführen - habe ich an CleanCode (Regel: pro Methode nur eine Abstraktionsebene) gedacht

das finde ich gut, allerdings bestehen Test aus 4 Schritten:
1. Setup
2. Exercise
3. Validate
4. Teardown

Kann dir das Buch "xUnit Test Patterns: Refactoring Test Code" sehr empfehlen.

Du nutzt ja schon "Custom Assertions", allerdings heissen die bei dir nicht so 😉
Deutsche Begriffe gehen gar nicht in Quellcode, führt nur zu hässlichem Denglish...

 

[DerSchokoBär]

Legst du für jeden einzelnen Fall einen manuellen String an?

    String attr1;
    String attr2;
    String attr3;
    String attr4;
    String attr5;

und legst für jedes Objekt eine eigene Methode (getAttr1(), getAttr2(), ...) an?

        attr1 = object.getAttr1();
        attr2 = object.getAttr2();

 

[Alenka87]

@Maki:
ich nutze schon englische Bezeichnungen, das hier war ehe so Pseudocode auf die schnelle🙂
Danke für den Buchtip, ich werd mich weiter in die Richtung informieren, da ich denk, das dies nicht meine letzten tests sind.

@DerSchokoBär:

Mal angenomen, mein Objekt ist "Person":

public class Person{

	String name;
	String vorname;
	String namenszusatz;
	String tital;
	/usw.
	
	Adresse adresse;
	Job job;
	Familie familie;
	/usw.
}

public class Adresse{
	String stadt;
	String land;
	String strasse;
	String hausnummer;
	String plz;
}

public class Job{
	String bezeichnung;
	String abteilung;
	String position;
	Person vorgesetzter;
	Adresse firmenanschrift;
}

public Familie;
	Person partner;
	Person mutter;
	Person vater;
	Job mutter;
	Job vater;
	Job partner;
	Andresse eltern;
}

Im ersten Testfall frage ich nur die persönlichen Daten ab: Name, Nachname, Adresse
Im zweiten Testfall frage ich die Informationen über den Job, dann zum Schluss alles über die Familie usw. :

...
@Test
public void test_persoenlicheInfo(){...}

@Test 
public void test_adresse(){...}

@Test
public void test_jobInfo(){...}

@Test
public void test_partnerPersoenlicheInfo(){...}

@Test
public void test_partnerJobInfo(){...}

@Test
public void test_mutterPersoenlicheInfo(){...}

@Test
public void test_mutterJobInfo(){...}


@Test
public void test_vaterPersoenlicheInfo(){...}

@Test
public void test_vaterJobInfo(){...}



...

oh jetzt ist mir der Groschen gefallen.... ist brauche doch keine tausend Testfälle, das kann doch alles in einem Testfall getestet werden, wenn das objekt sich nicht verändert?!?!?!