GUI-Testing: Jemmy & Marathon - Testen von Software

Testen von Software

   GUI-Testing:
Jemmy & Marathon

Kurzüberblick
Jemmy:                                  Marathon:
●   Ist eine Java-Bibliothek            ●   Ist ein Testing-Framework für GUI-
●   Zum Testen von Java-GUI-                Applikationen, welche Java/Swing
    Applikationen                           benutzen
●   Enthält Methoden, um                ●   Besteht aus einem Recorder-,
    Benutzereingaben bei Swing/AWT          Runner- und Editor-Tool
    Komponenten zu reproduzieren        ●   Die Testskripte werden mit Python
●   Lizenz: SPL                             Code erstellt
                                        ●   Ist ausgelegt für das
JemmyTest:                                  Endbenutzertesten mit einfachen
                                            Testskripten die „jeder“ lesen kann
●   Ist ein Java-Programm welches die   ●   Ist flexibel und erweiterbar
    Jemmy-API nutzt, um andere          ●   Für Anwendungen gut geeignet,
    Applikationen zu testen                 die auf dem forms-paradigm
●   Kann mit beliebigem Test-Harness        beruhen
    genutzt werden (z.B. Xtest)         ●   Lizenz: GNU LGPL
●   Kann genutzt werden, um Demos
    von Java-GUI-Applikationen zu
    schreiben

Jemmy - Projekt

●   Projekt-Seite: http://jemmy.netbeans.org

●   Community-Projekt von netbeans.org

●   4 Entwickler, 11 Observer

●   Aktuelle Version: 2.2.6 (April 2006)

●   Projekt-Plan: 2.2.7, 2.2.8, 3.0.0 (complete rewrite)

●   Mögliche zukünftige Funktion: recording module

●   SPL: Sun Public License

Jemmy - Funktionen

●   Finden von Fenstern und GUI-Komponenten

●   Reproduktion von Benutzereingaben

●   Erstellung von Demos möglich

●   Dump (von benutzten AWT/Swing-Komponenten)

●   Screenshots

●   GUIBrowser

Jemmy – How it Works
●   Test in selber JVM ausgeführt, wie zu testende Applikation

●   Schritt 1: Fenster finden
       org.netbeans.jemmy.WindowWaiter
       java.awt.Frame.getFrames()
       java.awt.Window.getOwnedWindows()

●   Schritt 2: GUI-Komponenten finden
       org.netbeans.jemmy.ComponentChooser
       java.awt.Container.getComponents()

●   Schritt 3: Mit den Komponenten arbeiten (Event Queue)
       org.netbeans.jemmy.operators.ComponentOperator
       org.netbeans.jemmy.QueueTool
       java.awt.EventQueue

Jemmy - EventQueue

●   Jemmy bringt eine eigene Implementierung der
    java.awt.EventQueue mit sich
●   JemmyQueue überschreibt dispatchEvent(AWTEvent) und ist eine
    private innere Klasse vom QueueTool
●   Funktionalität:
    public static void postEvent(AWTEvent event)
    public static void shortcutEvent(AWTEvent event)
    public static void processEvent(AWTEvent event)
●   EventDriver benutzt einfach nur QueueTool.processEvent(AWTEvent)

Jemmy - Testausführung
public class JemmyExampleTest implements Scenario {

    public int runIt(Object param) {
        try {
            // start application
            new ClassReference("example.jemmy.JemmyExampleFrame")
                    .startApplication();

            // test code ..

        } catch (Exception ex) {
            ex.printStackTrace();
            return 1;
        }
        return 0;
    }

    public static void main(String[] args) {
        Test.main(new String[] { "example.jemmy.JemmyExampleTest" });
    }
}

Jemmy – Fenster finden

// start application
new ClassReference("example.jemmy.JemmyExampleFrame")
       .startApplication();

// find frame (wait for frame)
JFrameOperator frame = new JframeOperator("JemmyExample");

// test code ..

Jemmy – Komponenten finden

// start application
new ClassReference("example.jemmy.JemmyExampleFrame")
       .startApplication();

// find frame
JFrameOperator frame = new JFrameOperator("JemmyExample");

// find text field
JTextFieldOperator textField = new JtextFieldOperator(frame);
// set text field text
textField.setText("Hello");

// find clear button
JButtonOperator clearButton = new JButtonOperator(frame, "Clear");
// and push it
clearButton.push();

Jemmy - GUIBrowser

●   org.netbeans.jemmy.explorer.GUIBrowser
●   Fensterapplikation zum Auflisten von aktuellen AWT/Swing-
    Komponenten mit Attributen
●   Dump und Screenshot sind möglich
●   Für nicht-automatisiertes Testen und zum Debuggen geeignet
●   Ermöglicht einen Überblick über verwendete Komponenten und
    deren Eigenschaften parallel zur Ausführung in einer Art
    Baumstruktur

Jemmy - Vor-/Nachteile
Vorteile:

  ●   Einfache Einbindung in ein bestehendes Projekt
  ●   Logisch strukturierte Bibliothek ermöglicht eine intuitive
      Bedienung für Java-Entwickler
  ●   Bietet vorgefertigte, komfortable Möglichkeiten für alle Standard-
      AWT/Swing-GUI-Komponenten
  ●   Entwicklerdokumentation und Source-Code liegt vor, somit steht
      einer Erweiterung für eigene Komponenten nichts im Weg
Nachteile:

  ●   Erstellung der Testfälle muß durch Java-Programmierer „von
      Hand“ getätigt werden
  ●   Ein Frontend für XML-Dumps existiert nicht

Marathon - Projekt

●   Projekt-Seite: http://marathonman.sourceforge.net

●   Entwicklung 2002 gestartet, im Juni 2004 wiederbelebt

●   2 Entwickler

●   Entwicklungsstatus: Production/Stable

●   Aktuelle Version: 0.90a

●   Letzte Änderung im November 2004

●   Lizenz: GNU LGPL

Marathon - Funktionen

●   Recorder zum Aufzeichen von Events (Konvertierung in einen
    abspielbaren Testfall erfolgt)
●   Runner zum Abspielen von aufgezeichneten und selbsterstellten
    Testfällen (interaktiv oder per Kommandozeile)
●   Editor zum komfortablen erstellen und editieren von Testfällen in
    der Sprache Python (Jython)
●   Geeignet für smoke testing, regression testing und formal
    acceptance testing

Marathon - Aufruf

●   Interaktives GUI aufrufen
    marathon
●   Interaktives GUI zu einem speziellen Projekt aufrufen
    marathon MPF
●   Testfälle ausführen
    marathon -batch [-text ] [-html ] [-xml ] MPF [ TestCase ...]
●   Hilfe-Option: zeigt die allgemeine Hilfe an
    marathon -help

Marathon - Projekterstellung

●   MPF anlegen/konfigurieren/öffnen
●   Name und Beschreibung
●   Projektverzeichnis
●   Main-Class
●   Programm-Parameter / VM-Parameter / Arbeitsverzeichnis
●   Classpath
●   Python-Pfade für externe Module
●   Resolvers
●   Properties
●   Testen und Speichern

Marathon – Hauptfenster

●   3-geteilt in Navigator-Panel, Editor-Panel und Konsolen-Panel
●   Neue Testfälle und Aufzeichnungen anlegen und speichern
●   Aufzeichnungen starten, abspielen, pausieren und stoppen
●   Applikationen starten und stoppen
●   Testfälle/Testaufzeichnungen anschauen und editieren
●   Möglichkeit zum Setzen von Breakpoints innerhalb der Testfälle
●   Editor mit Syntax Coloring für die Testfälle
●   Konsole für die Standardausgabe

Marathon -
          Fenster/Komponenten
●   Finden der richtigen Komponten durch Suchreihenfolge:
    1. Fenster (Fenstertitel)
    2. Name der Komponente (setName)
    3. Label (zB. Buttontext)
    4. Klassenname
●   Unterscheidung dennoch gleicher Komponenten durch anhängen
    einer laufenden Nummer
●   Erweiterung um eigene Komponenten über ComponentResolver
    und MComponent

Marathon - Testfall

useFixture(default)

def test():
   window('Simple Widgets')
   select('tabbedpane', 'Table Demo')
   close()

   window('Table Demo')
   select('Table', 'Dakshinamurthy K', 'Name,0')
   select('Table', '40', 'Age,0')
   select('Table', 'true,', 'Marital Status,0')
   sleep(1)
   close()

Marathon - Vor-/Nachteile
Vorteile:

   ●   Externes Tool mit grafischer Benutzeroberfläche
   ●   Läßt sich leicht an ein bestehendes Projekt ankoppeln
   ●   Ist gut handhabbar auch für Nichtentwickler
   ●   Spielend einfache Erstellung von Testfällen durch den Rekorder
   ●   Benutzung der GUI ist umfassend dokumentiert

Nachteile:

   ●   Wenn doch mal von Hand ein Testfall erstellt oder verändert
       werden soll, muss man sich in die Skriptsprache reinarbeiten
   ●   Eine Dokumentation der bestehenden Skriptelemente ist nur
       angedeutet und keinesfalls ausreichend
   ●   Eine Weiterentwicklung und ein Support ist nicht erkennbar

Jemmy & Marathon
                im Vergleich
●   Jemmy ist eher an Entwickler gerichtet, die parallel zum
    Entwickeln Testfälle erstellen (programmieren)
●   Marathon wendet sich eher an Nichtentwickler, die mit der GUI
    ihre Testfälle erstellen (aufnehmen) sollen
●   Jemmy bietet mehr Möglichkeiten aufgrund der Nähe zum Java-
    Code
●   Marathon ist dafür einfacher und schneller handhabbar
●   An Jemmy wird aktiv weiterentwickelt (Java 5, Rekorder)
●   Marathon gilt seit 2004 als stable

Testen von Software

       GUI-Testing:
    Jemmy & Marathon

Vielen Dank für Ihre
 Aufmerksamkeit.