# JUnit Test Suite erstellen



## DarthShader (14. Dezember 2007)

Hallo,

ich würde gerne ein paar JUnit-Tests durchführen, und diese Tests in einer JUnit-Test-Suite zusammenfassen, um alle gemeinsam auszuführen. Ich benutze Eclipse 3.3.0 Europa Release, und JUNit 4.4.3.1 (glaube ich jedenfalls, im Eclipse/Plugin Ordner gibt es das Verzeichnis "org.junit4_4.3.1" - allerdings gibt es auch das Verzeichnis "org.junit_3.8.2.v200706111738", welches jedoch leer ist).

Um einen Test zu erstellen, mache ich nen REchtsklick im Package Explorer und wähle "New" -> "JUnit Test Case". Dann kann ich verschiedene Method-Stubs auswählen, alles wird erstellt und ich kann diesen Test fahren.

Wähle ich jedoch "New" -> "JUnit Test Suite", so erscheint das Fenster für eine neue Test-Suite und im unteren bereich könnte man die Testklassen auswählen, die in die Suite eingefügt werden sollen. Dieses ist bei mir jedoch leer und ich sehe keine Möglichkeit, dort Tests hinzuzufügen (es gibt neben der Liste nur die Buttons "Select All" und "Deselect All").

Finishe ich das ganze, so wird eine Datei mit diesem Inhalt erstellt:


```
public class AllTests
{
	public static Test suite()
	{
		TestSuite suite = new TestSuite( "Test for de.test.lib" );
		//$JUnit-BEGIN$
		
		//$JUnit-END$
		return suite;
	}
}
```


Aber was soll ich damit anfangen? Wieso kann ich in dem Wizard meine Test-Klassen nicht sehen?


Über Hilfe würde ich mich sehr freuen!


Vielen Dank


----------



## DarthShader (20. Dezember 2007)

Kann mir denn keiner helfen? Ich möchte doch nur alle meine JUnit Tests in einer Suite zusammen ausführen. Aber warum stehen meine Tests nicht in dem Neue-JUnit-Test-Suite-Wizard-Fenster? Ich weiß einfach nicht, wie ich da meine Tests hinzufügen kann :-/


----------



## Andron (20. Dezember 2007)

Versuch mal so:


```
suite.addTestSuite(MeineKlasseTest.class);
```

Übrigens, es gibt viele gute Seiten, auch auf Deutsch, wo das alles erklärt ist.
Z.B.: http://www.torsten-horn.de/techdocs/java-junit.htm


----------



## DarthShader (22. Dezember 2007)

Andron hat gesagt.:


> Versuch mal so:
> 
> 
> ```
> ...



Danke für Deinen Vorschlag. Wenn ich jedoch mit Eclipse einen neuen JUnit Test erstelle (mit dem Wizard, der mir schonmal alle Method Stubs erstellt), dann ist der Test eine einfache Klasse, die nicht von "TestCase" abgeleitet ist. Ich kann den Test dennoch problemlos ausführen!

Das hier funktioniert z.B.:


```
@Test( expected = RuntimeException.class )
public void testBaseDirCheck() {
	// Must throw a runtime exception if basedir not exist
	@SuppressWarnings( "unused" )
	ResourceManager rm = new ResourceManager( "this/should/not/exist" );
}
```

Das Verzeichnis existiert nicht, und die Klasse ResourceManager sollte eine RuntimeException werfen. Da dies mit der Annotaion "@Test( expected = RuntimeException.class )" angegeben wurde, ist der Test erfolgreich.

Diese vorgehensweise habe ich aus irgendeinem Beispiel... ich glaube von der JUnit Doku selbst.

Leite ich die Testklasse nun von "TestCase" ab, um Dein Vorschlag mit "suite.addTestSuite(MeineKlasseTest.class);" zu verwenden, so schlägt mein Testcode von oben fehl, obwohl er es nicht sollte.

Irgendwas stimmt doch hier nicht - wieso z.B. leitet Eclipse meine Testklasse nicht gleich von "TestCase" ab? Kann es vielleicht daran liegen, dass ich die neueste Version von JUnit verwende?

Hat sonst noch jemand eine Idee?


Vielen Dank!


----------



## DarthShader (24. Dezember 2007)

Kann mir denn keiner helfen? Ich verstehe meine Problematik einfach nicht.Ist es immer so, dass Test-Klasse von "TestCase" abgeleitet werden? Aber warum macht Eclipse das dann nicht automatisch beim Erstellen einer solchen Testklasse? Und wieso funktioniert mein oben angegebener Unit Test nicht mehr, wenn ich von "TestCase" ableite?

Über Hilfe würde ich mich wirklich sehr freuen

Danke!


----------



## zeja (25. Dezember 2007)

Nunja es handelt sich da um unterschiedliche Vorgehensweisen. Die eine ist Tests über Annotations durchzuführen und die andere manuell über Code.

Wenn du sie mit normalen Code ausführen willst dann erweiterst du TestCase, lässt jede Methode mit test beginnen und benutzt assert um den Vergleich von erhaltenem Ergebnis und gewünschten Ergebnis durchzuführen.

Dort scheint es eine nette Übersicht zu geben: http://www.frankwestphal.de/JUnit4.0.html

Das Problem ist wohl dass Eclipse nur Klassen zur Auswahl anbietet die TestCase erweitern, nur dass passt eben nicht zum neuen Prinzip der Testerstellung mit Annotations. Also musst du die Klassen selber zur Suite hinzufügen: http://radio.javaranch.com/lasse/2006/07/27/1154024535662.html


----------



## DarthShader (27. Dezember 2007)

Danke für Deine Antwort. Der letzte Link ist genau das, was ich gesucht hatte - ich konnte es einfach nicht finden und stieß immer wieder nur auf Codebeispiele, bei denen die Testsuites auf die "alte" Weise eingebunden wurden.

Allerdings frage ich mich, warum Eclipse wunderbar damit klarkommt, einen UnitTest mit Annoatations zu erstellen, aber keine TestSuite auf die neue Art und weise generieren kann, schon merkwürdig.


----------



## hagbard23 (12. November 2008)

ich mache das so...:

testklasse1:

```
public class TestSth extends TestCase
{

    public void setUp() throws Exception
    {
        //set up sth
    }

    public void testLoadSubordinateAssembly() throws Exception
    {
       //test sth 
    }

    public void tearDown() throws Exception
    {
     //tear down sth
    }
}
```

testklasse2:

```
public class TestSthOther extends TestCase
{

    public void setUp() throws Exception
    {
        //set up sth
    }

    public void testLoadSubordinateAssembly() throws Exception
    {
       //test sth 
    }

    public void tearDown() throws Exception
    {
     //tear down sth
    }
}
```

und dann:

```
package editorTests;

import junit.framework.Test;
import junit.framework.TestSuite;

import junit.textui.TestRunner;

public class EditorTests extends TestSuite
{

    public static void main(String[] args)
    {
        TestRunner.run(suite());
    }

    public static Test suite()
    {

        TestSuite suite = new EditorTests("editor Tests");
        suite.addTestSuite(TestSthOther .class);
        suite.addTestSuite(TestSth.class);
        return suite;
    }

    public EditorTests(String name)
    {
        super(name);
    }

}
```


----------



## Oliver Gierke (12. November 2008)

Jap, aber das ist JUnit 3.8. Ich glaube DarthShader hat der Mischmasch aus dem 4er Annotationsstyle (in den Testklassen) und dem 3er Suiteaufbau irritiert.

Gruß
Ollie


----------



## hagbard23 (13. November 2008)

was ist denn eigentlich das tolle neue an junit 4?


----------



## Oliver Gierke (13. November 2008)

Es ist einiges flexibler (kein Zwang, sich in eine Klassenhierarchie zu hängen), vieles kürzer ("expected" and der @Test Annotation um das Fliegen einer Exception zu erwarten) usw. usw. Kein Riesenunterschied, eher subtile Änderungen, die hier und da schon Erleichterung bringen. Google ist dein Freund, es gibt massig Vergleiche da draussen 

REINHAUN!


----------



## hagbard23 (13. November 2008)

na ich komm gut klar mit 3.8...wenn ich ein neues testsys aufsetze, werde ichs mir mal anschaun...


----------



## Oliver Gierke (13. November 2008)

Jap, das meinte ich mit "subtil, aber hier und da leichter". Ein bestehendes Projekt würde ich auch nicht umstellen. Neues mit 4 anzufangen macht aber durchaus Sinn.

Gruß
Ollie


----------



## hagbard23 (13. November 2008)

die dinge die ich gern machen würde sind anders...

bsp. vernünftiges gui testing...ich benutze gerade swt bot, sehr geiles teil aber noch etwas grün hier und da...der witz is das das auch unit tests sind....

mocking ohne spring bze. dependecy injection...da gibs sachen easyMock oder so, hab ich mir noch nicht anschaun können...

grobgranulare tests auf package/eclipse plugin ebene...


----------



## Oliver Gierke (13. November 2008)

hagbard23 hat gesagt.:


> die dinge die ich gern machen würde sind anders...
> 
> bsp. vernünftiges gui testing...ich benutze gerade swt bot, sehr geiles teil aber noch etwas grün hier und da...der witz is das das auch unit tests sind....


Nananana... vorsicht. Nur weil Test mit JUnit implementiert sind, sind sie noch lange keine Unittests. Ein Unittest definiert sich nicht über die technologie mit der er umgesetzt ist, sonder im Umfang des zu testenden Codes - ergo in der definition, was eine Unit überhaupt ist. Im Normalfall ist das eine einzelne Klasse, deren Dependencies gemockt werden.



> mocking ohne spring bze. dependecy injection...da gibs sachen easyMock oder so, hab ich mir noch nicht anschaun können...


Mocking ohne Spring geht, Mocking ohne DI ist effektiv unmöglich. D.h. ohne einen auf Dependency Injection zugeschnittenen Entwurf und eine Mockbibliothek sind effektive Unittests quasi aussichtslos 



> grobgranulare tests auf package/eclipse plugin ebene...


Äh jap... Eclipse testen soll nicht einfach sein, hab ich mir sagen lassen .

Gruß
Ollie


----------



## fjfvo (15. November 2008)

Hallo zusammen,

hier ein Beispiel:


```
package tournament;

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(value = Suite.class)
@Suite.SuiteClasses(value = { PlayerTest.class, TournamentGameTest.class, 
GroupGameTest.class, MyStackTest.class, MyQueueTest.class, 
TournamentTest.class, GroupTest.class })
public class TestAll {

	public TestAll() {
	}
}
```

Und eine von den Test-Klassen:


```
import static org.junit.Assert.*;

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

public class PlayerTest {

	private Player jan;
	private Player piet;

	@Before
	public void setUp() throws Exception {
		jan = new Player("Jan");
		piet = new Player("Piet");
	}

	@After
	public void tearDown() throws Exception {
		jan = null;
		piet = null;
	}

	@Test
	public void testHand() {
		assertTrue(Hand.PAPER.equals(Hand.PAPER));
		assertFalse(Hand.PAPER.equals(Hand.ROCK));
	}

	@Test
	public void testPlayHand() {
		jan.setHand(Hand.ROCK);
		piet.setHand(Hand.ROCK);
		int q = jan.getHand().compareTo(piet.getHand());
		assertTrue(q == 0);
		piet.setHand(Hand.SCISSORS);
		q = jan.getHand().compareTo(piet.getHand());
		assertTrue(q < 0);
		piet.setHand(Hand.PAPER);
		q = jan.getHand().compareTo(piet.getHand());
		assertTrue(q < 0);
	}
}
```

Gruß .


----------

