Jemmy

Homepage

Projektseite: http://jemmy.netbeans.org/
Download-Seite: http://jemmy.dev.java.net/

Lizenz

COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0 und GPLv2

Letzter Untersuchungszeitpunkt

01.11.2010

Jemmy ist ein einfaches Tool zur Automatisierung von auf AWT und Swing basierenden grafischen Benutzeroberflächen unter Java. Da das Tool selbst auf Java basiert, kann es plattformunabhängig eingesetzt werden.

Fazit

Jemmy ist aufgrund seiner schlicht gehaltenen Dokumentation sicher nicht die beste Wahl bei der Suche nach einem anständigen GUI-Automatisierungstool. Es war zunächst sehr schwer herauszufinden, wie das Tool innerhalb eines eigenen Projektes überhaupt einzusetzen ist. Jedoch stellte sich heraus, dass sich mit relativ wenig Aufwand einfache GUI-Abläufe implementieren ließen.
Der mitgelieferte "GUI Browser" ist ein etwas misslungenes Tool, welcher der Betrachtung der Interna der grafischen Oberflächen dient. Die Funktion des "Dumps" in eine XML-Datei ist sicherlich eine hervorragende Idee, aber leider grauenvoll umgesetzt.
Insgesamt macht das Projekt einen sehr unausgereiften und lustlosen Eindruck. Beim Download der "jemmy.jar"-Datei, nachdem man den Link gefunden hat, wird nicht einmal die Version des Tools verraten.
Die auf der Homepage zur Verfügung gestellten Beispiele wären sicher aufschlussreicher, wenn sie denn ohne zusätzliche Manipulationen funktionieren würden.

Einsatzgebiete

Das Testen von GUI-Anwendungen, die mit Swing oder AWT programmiert wurden. SWT und andere kleinere Frameworks werden offiziell nicht unterstützt.

Einsatzumgebungen

Das GUI-Automatisierungstool Jemmy kann, obwohl es sich um ein von Netbeans zur Verfügung gestelltes Projekt handelt, in jeder Entwicklungsumgebung eingesetzt werden. Da es als Java-Archiv vorliegt muss es hierzu lediglich in den Classpath eines Java-Projekts eingebunden werden. Jemmy integrierte sich noch bis Version 6.1 in die Oberfläche von Netbeans mit einem Tool, dem "GUI Browser", welcher die Komponenten einer GUI erkennen und auswerten konnte. Dieser Browser lässt sich allerdings auch ganz einfach über den Aufruf der Klasse "org.netbeans.jemmy.explorer.GUIBrowser" manuell starten.

Installation

Zum Betreiben von Jemmy muss lediglich eine Jar-Datei heruntergeladen und in das Projekt eingebunden werden, auf deren Klassen und Methode die Tests dann später aufbauen.
Komfortabler war bis zur Netbeans-Version 6.1 der Einsatz des Jemmy-Plugins. Jedoch kam es beim Einrichten per PlugIn-Manager zu schweren Fehlern, so dass eine Neuinstallation von Netbeans nötig war. Sicher wurde aus diesem Grund das Jemmy-PlugIn aus Netbeans 6.5 verbannt.

Dokumentation

Eine Dokumentation liegt in Form eines nicht allzu gut gehaltenen "Tutorials" und einigen einfachen "Examples" vor. Das Tutorial beginnt schon mit dem Satz "This tutorial below doesn't expose Jemmy functionality very much." und lässt schon vermuten, dass hier keine besonders hilfreichen Informationen folgen.
Im Tutorial werden dann die meisten grafischen Komponenten, auf welche Jemmy reagieren kann, knapp erläutert und Beispiel-Code in Form von java-Dateien mitgeliefert.
Auf die Benutzung des "GUI-Browsers", welcher die eigentliche GUI von Jemmy darstellt, oder wie die Jemmy-Funktionaliät im eigenen Java-Projekt Verwendung findet, wird gar nicht weiter eingegangen.

Wartung der Projektseite

Die auf Netbeans.org gehostete Projektseite ist äußerst unübersichtlich und bietet zahlreiche Links, die ins Leere führen. So ist der Downloadlink sehr schwer aufzufinden. Über den "Files"-Link am rechten Rand der Seite erreicht man nur eine "Readme.txt" in welcher auf die Seite http://jemmy.netbeans.org/downloads.html verwiesen wird. Eine übersichtliche Gliederung der einzelnen Seiten z.B. in der Linkleiste am rechten Rand sucht man vergebens. Obwohl das Projekt augenscheinlich noch lebt und es immer wieder neue Versionen von Jemmy gibt, spiegelt sich das nicht in Aktualisierungen der Projektseite wieder. So sind beispielsweise die letzten News vom 10.01.2006!

Nutzergruppen und Support

Auf der Projektseite findet sich nur eine Mailinglist, die aber mit durchschnittlich weniger als 10 Nachrichten pro Monat nicht sehr häufig frequentiert wird. Andere Möglichkeiten mit den Entwicklern in Kontakt zu treten, sind nicht vorgesehen, auch eine Emailadresse sucht man vergebens. Die Projektseite bietet des Weiteren einen Bugtracker, der von den Jemmy-Entwicklern aber ungenutzt bleibt.

Intuitive Nutzbarkeit

Aufgrund der schlechten Dokumentation war es nicht unmittelbar möglich herauszufinden, wie Jemmy zu benutzen ist. Die bereitgestellten Beispiele, welche mit Hilfe des eingebauten GUI-Browsers die Funktionalitäten von Jemmy aufzeigen sollen, lassen sich allesamt nicht ohne vorherige Manipulationen ausführen. Die Entwickler haben hier offenbar übersehen, dass Buttons in der Browser-GUI mittlerweile umbenannt wurden. Diese werden in den Test-Beispielen dadurch nicht korrekt angesprochen und die Tests bleiben einfach mittendrin stehen.

Automatisierung

Ein spezielles Konzept zum Ausführen von Jemmy-Tests z.B. mit Ant gibt es nicht. Tests werden einfach in gewöhnliche Klassen verpackt, die sich anschließend sowohl manuell als auch automatisiert aufrufen lassen.

ANT

Die Automatisierung von Jemmy mit Hilfe von Ant gestaltet sich schwierig, da kein Report oder ähnliches erzeugt wird. Es wird lediglich eine Oberfläche angezeigt, an Hand der das Ergebnis der Tests überprüft werden kann. Es besteht zwar eine Konsolenausgabe, die allerdings nicht sehr viel Informationen über den kompletten Testlauf beinhaltet. Somit ist eine Automatisierung der Testläufe mit Hilfe des Jemmy-Frameworks nicht besonders förderlich, da Jemmy eine eigenständige Oberfläche anbietet, anhand derer die Ergebnisse überprüft werden können.

Maven

analog zum Kapitel Ant

Einführendes Beispiel

Der Anwender hat die Möglichkeit Jemmy auf der Konsole oder innerhalb einer Entwicklungsumgebung (hier vorzugsweise Netbeans) zu verwenden.

Im ersten Fall ist es lediglich notwendig den Classpath zu setzen und daraufhin das Programm zu kompilieren und auszuführen:


   export CLASSPATH=$CLASSPATH:/path/to/jemmy.jar
   javac ClassName.java
   java ClassName

Bei der Verwendung innerhalb einer Entwicklungsumgebung muss die Datei "jemmy.jar" als "External JAR" dem Build-Path des Projektes hinzugefügt werden.

Der Einsatz von Jemmy soll im Folgenden am Beispiel einer einfachen GUI zum Zeichnen von Polygonen gezeigt werden. Das in NetBeans erstellte Projekt kann hier heruntergeladen werden.

Um die Funktionen von Jemmy zu nutzen, müssen Klassen aus dem Namensraum der "jemmy.jar" in die eigene Klasse importiert werden:


   import org.netbeans.jemmy.*;
   import org.netbeans.jemmy.explorer.*;
   import org.netbeans.jemmy.operators.*;

Die zu testende Klasse muss das Interface "Scenario" implementieren und die Funktion "runIt(Object param)" überschreiben.


   public class PolyJemmy implements Scenario {

   	public int runIt(Object param) {
   		/*
   		  Zu implementierende Interaktionen mit der GUI
   		*/
   		} catch(Exception e) {
   			e.printStackTrace();
   			return(1);
   		}
   		return(0);
   	}

   }

Ein Test für die Klasse "ClassName" wird dann wie folgt aufgerufen:


   public static void main(String[] args) {
   	String[] params = {"ClassName"};
   	org.netbeans.jemmy.Test.main(params);
   }

Innerhalb der "runIt()"-Methode können nun weitere Java-Programme gestartet werden, deren GUI-Elemente daraufhin anhand diverser Jemmy-Methoden bedient werden können. Das Polygon-Zeichenprogramm (im NetBeans-Projekt enthalten) liegt als Jar-Datei vor und wird ebenso wie Jemmy in den Classpath des Projektes eingebunden. Innerhalb von "runIt()" wird das Programm wie folgt gestartet und das Frame mit dem Namen "Polygone" zur Anzeige geladen:


   new ClassReference("de.fhwiesbaden.poly.PolygonGUI").startApplication();
   JFrameOperator mainFrame = new JFrameOperator("Polygone");

Nun muss zunächst ein neues Polygon angelegt werden. Hierzu wird automatisiert der Button "Neues Polygon" betätigt und daraufhin die Zeichenfläche über den Button "Polygon zeichnen" geöffnet.


   new JButtonOperator(mainFrame, "Neues Polygon").push();
   new JButtonOperator(mainFrame, "Polygon zeichnen").push();

Das sich öffnende Frame der Zeichenfläche wird nun ebenfalls wie das Hauptfenster in eine Framevariable geladen, so dass mit ihr interagiert werden kann. Hier soll nun die Form eines Hauses gezeichnet werden. Hierzu wird die linke Maustaste automatisch an bestimmten Koordinaten gedrückt und mit Betätigung der Taste "n" der einzelne Polygonpunkt gezeichnet:


   JFrameOperator paintFrame = new JFrameOperator("\"Polygone\" by Andreas Lind");
   paintFrame.clickMouse(200, 300, 1);
   paintFrame.pressKey('n');
   paintFrame.clickMouse(400, 300, 1);
   paintFrame.pressKey('n');
   paintFrame.clickMouse(400, 500, 1);
   paintFrame.pressKey('n');
   paintFrame.clickMouse(200, 500, 1);
   paintFrame.pressKey('n');
   paintFrame.clickMouse(200, 300, 1);
   paintFrame.pressKey('n');
   paintFrame.clickMouse(300, 200, 1);
   paintFrame.pressKey('n');
   paintFrame.clickMouse(400, 300, 1);
   paintFrame.pressKey('n');
   paintFrame.waitClosed();

Damit man das Ergebnis der Zeichnung sehen kann wurde in der letzten Zeile "waitClosed()" für das Zeichenpanel aufgerufen:

haus

Auf der Konsole erscheinen nun einige von Jemmy erzeugte, sehr ausführliche Meldungen. Hier ein Ausschnitt:


1:	Using org.netbeans.jemmy.drivers.DefaultDriverInstaller driver installer
2:	Reproduce user actions through event queue.
3:	Use event dispatching to reproduce user actions
4:	Shortcut test events
5:	Using org.netbeans.jemmy.drivers.DefaultDriverInstaller driver installer
6:	Executed test de.test.jemmy.PolyJemmy
7:	Test de.test.jemmy.PolyJemmy has been started
8:	Trace:
9:	Start to wait action "Test de.test.jemmy.PolyJemmy finished"
10:	Trace:
11:	Start to wait frame "Frame with title "GUI Browser"" opened
12:	Trace:
13:	Frame "Frame with title "GUI Browser"" has been opened in 1 milliseconds
	...
14:	Trace:
15:	Start to wait frame "Frame with title "Polygone"" opened
	...
16:	Trace:
17:	Start to wait action "Wait AbstractButton with text "Polygon zeichnen" loaded"
	...
18:	Push button
19:	    :javax.swing.JButton[,10,150,143x25, ... ,text=Polygon zeichnen,defaultCapable=true]
20:	Trace:
21:	Start to wait frame "Frame with title ""Polygone" by Andreas Lind"" opened
22:	Trace:
23:	Frame "Frame with title ""Polygone" by Andreas Lind"" has been opened in 0 milliseconds
	...
24:	org.netbeans.jemmy.TestCompletedException: Test passed
25:	        at org.netbeans.jemmy.Test.closeDown(Test.java:155)
26:	        at org.netbeans.jemmy.Test.launch(Test.java:382)
27:	        at org.netbeans.jemmy.ActionProducer.launchAction(ActionProducer.java:341)
28:	        at org.netbeans.jemmy.ActionProducer.run(ActionProducer.java:298)
29:	Trace:
30:	"Test de.test.jemmy.PolyJemmy finished" action has been produced in 1658 milliseconds with result
31:	    : 0
32:	BUILD SUCCESSFUL (total time: 1 second)

Zeile 1-5: Jemmy-Module werden geladen
Zeile 6-7: Initialisieren der Klasse und Starten der Testmethode
Zeile 8-23: Jemmy verfolgt Events wie Mausklicks oder Tastatureingaben
Zeile 24-32: Meldung "Test passed" - Testlauf war erfolgreich

Diese Informationen werden bei größeren Programmen mit höherem Aufwand an GUI-Interaktionen zu unübersichtlich, so dass hier eine strukturiertere Darstellungsart wünschenswert ist.
Hierfür sorgt allerdings der in Jemmy integrierte "GUI Browser", welcher nun ganz einfach zu Beginn der "runIt()"-Methode geladen werden kann:


   new ClassReference("org.netbeans.jemmy.explorer.GUIBrowser").startApplication();
   new JFrameOperator("GUI Browser");

Wird das Programm nun ausgeführt, öffnet sich zusätzlich das Fenster des GUI Browsers:

gui_browser

In diesem wird dann der Button "Reload in ..." betätigt (die Eingabe einer Wartezeit bis zum Reload ist ebenfalls möglich).
Daraufhin erscheinen unter dem Eintrag "View" Einträge zu den drei geöffneten Frames, zu denen sich über den Button "View" ein Fenster mit weiteren Eigenschaften öffnen lässt:

Hierarchy:
--> Zeigt den Klassenvererbungsbaum vom jeweiligen Panel (hier: PolygonPanel).

hierarchy

Properties:
--> Zeigt die Eigenschaften des Fensters, wie Höhe, Breite, Mausposition, Veränderbarkeit der Größe, ...

properties

Reflection:
--> Zeigt zu allen an der Darstellung beteiligten Java-Komponenten die möglichen Methoden.

reflection

Image: --> Zeigt einen Screenshot des jeweiligen Fensters.

Nun besteht noch die Möglichkeit die Ergebnisse über den Button "Dump" in eine XML-Datei abzuspeichern. Dies endet leider in einer gewaltigen Datei (in diesem Fall gute 100 KB groß!), welche noch deutlich unübersichlicher ist, als die Konsolenausgaben von Jemmy.

Hinweis: Der GUI-Test beendet sich grundsätzlich nach 60 Sekunden. Ein Grund dafür konnte nirgendwo gefunden werden.

Detaillierte Beschreibung

Nicht gefunden.

Literatur

keine.

Zurück zur Werkzeugübersicht
Zurück zur CSI-Hauptseite

Name