Die Programmiersprache Java dient innerhalb der Java-Technologie vor allem zum Formulieren von Programmen. Diese liegen zunächst als reiner, menschenverständlicher Text vor, dem sogenannten Quellcode. Dieser Quellcode ist nicht direkt ausführbar. Erst der Java-Compiler, der Teil des Entwicklungswerkzeugs ist, übersetzt es in die Maschinensprache Java-Bytecode. Die Maschine, die diesen Bytecode ausführt, ist jedoch typischerweise virtuell. Folglich findet die Ausführung nicht direkt über die Hardware bzw. etwa einem Mikroprozessor ausgeführt, sondern durch entsprechende Software auf der Zielplattform.

Zweck der Virtualisierung ist die Plattformunabhängigkeit. Das Programm soll ohne weitere Änderung auf jeder Rechnerarchitektur laufen, wenn dort eine passende Laufzeitumgebung installiert ist. Oracle selbst bietet Laufzeitumgebungen für die Betriebssysteme Linux, macOS, Solaris und Windows an. Andere Hersteller lassen eigene Java-Laufzeitumgebungen für ihre Plattform zertifizieren. Auch in Autos, HiFi-Anlagen und anderen elektronischen Geräten wird Java verwendet.

Um die Ausführungsgeschwindigkeit zu erhöhen, werden Konzepte wie die Just-in-time-Kompilierung und die Hotspot-Optimierung verwendet. In Bezug auf den eigentlichen Ausführungsvorgang kann die JVM den Bytecode so interpretieren, bei Bedarf jedoch auch kompilieren und optimieren.

Eine kurze Zeitreise

Im Grunde genommen ist es eine Person, die für die Entstehung der objektorientierten Programmiersprache Java verantwortlich ist. James Gosling.

James Gosling schloss sein Studium an der University of Calgary im Jahr 1977 mit dem Bachelor of Science in Informatik ab. Sechs Jahre später erhielt er den Doktortitel. Während seiner Doktorarbeit schrieb er 1981 den ersten Emacs für Unix-Systeme in C. Seine Implementierung wurde unter dem Namen Gosling Emacs (Gosmacs) bekannt. Neben Compilern und Mailsystemen erfand er bei Sun Microsystems in den 80ern gemeinsam mit David S. H. Rosenthal auch das nicht mehr weiterentwickelte Windowing-System „NeWS (Network extensible Window System)“, welches ursprünglich unter dem Namen SunDew bekannt war.

Bei seiner Arbeit von 1984 bis 2010 arbeitete Gosling bei Sun Microsystems, in dieser Zeit entwarf er auch das originäre Design von Java. Den Grundstein für diese Programmiersprache hatte er bereits während seines Studiums gelegt. Dort entwickelte er auch eine virtuelle CPU, die P-Code als Maschinensprache ausführte. Das Konzept dieser Pseudo-Maschine übertrug Gosling später auf die architekturneutrale Ausführung weitverbreiteter Programme.

Im Jahr 2005 erhielt Gosling den Titel zum Chief Technical Officer der Produktentwicklung bei Sun Microsysems.

Java als Open Source bzw. Freie Software

Sun hatte zugesichert, die JDK unter der GNU General Public License zu veröffentlichen. mit der Übernahme durch Oracle wurde auch die offene Lizenzierung übernommen. Am 13. November 2006 haben sie erste Teile der JDK bereits mit dem Compiler javac und der Hotspot Virtual Machine als Open Source veröffentlicht. Zudem hat man mit OpenJDK eine Community-Seite eröffnet, mit deren Hilfe man die Entwicklung koordinierte. Am 8. Mai 2007 folgten große Teile des „Java-SE“-Quellcodes zum Erstellen eines JDK. Eine Ausnahme stellte solcher Code dar, für den Sun nicht die nötigen Rechte besaß, um diesen freizugeben. Dieser liegt somit nur in kompilierter Form vor. Ebenfalls kündigte Sun an, dass Entwicklungen auf Grundlage des OpenJDK das „Java Compatible“-Logo führen, wenn sie nach dem „Java Compatibility Kit“ (JCK) zertifiziert sind.

Zuvor hat man den Quelltext von Java unter anderem bei jedem JDK mitgeliefert und ermöglichte so zwar Einsicht, doch man durfte diesen nicht beliebig modifizieren. Aus diesem Grund gibt es neben den offiziellen JCP auch diverse unabhängige Vereinigungen, die es sich zum Ziel gesetzt haben, ein unter einer freien Open-Source-Lizenz gestelltes Java bereitzustellen. Die bekanntesten dieser Projekte sind Apache Harmony, Kaffe und das GNU-Classpath-Projekt gewesen. Gegenwärtig gibt es neben OpenJDK noch eine weitere große Implementierung, die aktuelle Java Releases veröffentlicht, Eclipse OpenJ9. Diese JVM-Implementierung hat IBM an die Eclipse Foundation übergeben. OpenJ9 steht mehrfachlizenziert unter EPL 2.0, Apache 2.0 und GNU 2.0 with Classpath Exception zur Verfügung. Darüber aber mehr in meinem Eclipse Beitrag.

Java ist mitunter eines der populärsten Programmiersprachen. In dem seit 2001 veröffentlichten TIOBE-Index lag Java bis 2020, konkurrierend mit C, stets auf den ersten beiden, seit 2021 mit zusätzlicher Konkurrenz von Python, auf den ersten drei Plätzen des Rankings. Nach dem RedMonk-Programmiersprachenindex 2019 liegt Java zusammen mit Python auf dem zweiten Platz nach JavaScript.

Das Grundkonzept von Java

Der Entwurf der Programmiersprache strebte hauptsächlich fünf Ziele an:

1. Sie soll eine einfache, objektorientierte, verteilte und vertraute Programmiersprache sein.
   Java ist im Vergleich zu anderen objektorientierten Programmiersprachen wie C++ oder C# einfacher, da es einen reduzierten Sprachumfang besitzt und beispielsweise Operatorüberladung und Mehrfachvererbung nicht unterstützt.
   
2. Sie soll robust und sicher sein.
   Viele der Designentscheidungen bei der Definition von Java reduzieren die Wahrscheinlichkeit ungewollter Systemfehler. Beispiele dafür sind die starke Typisierung, Garbage Collection, Ausnahmebehandlung sowie der Verzicht auf Zeigerarithmetik. Für die Sicherheit stehen Konzepte wie der Class-Loader, der die sichere Zuführung von Klasseninformationen zur Java Virtual Machine steuert und der Security-Manager, die sicherstellen, dass nur Zugriff auf Programmobjekte erlaubt wird, für die entsprechende Rechte vorhanden sind.
   
3. Sie soll architekturneutral und portabel sein.
   Java ist so entwickelt, dass dieselbe Version eines Programms prinzipiell auf einer beliebigen Computerhardware läuft, unabhängig von ihrem Prozessor oder anderen Hardwarebestandteilen. Zusätzlich zur Architekturneutralität ist es portabel. Folglich sind elementare Datentypen sowohl in ihrer Größe und der internen Darstellung als auch in ihrem arithmetischen Verhalten standardisiert. Beispielsweise ist ein float immer ein IEEE 754 Float von 32 Bit Länge. Dasselbe gilt beispielsweise auch für die Klassenbibliothek, mit deren Hilfe man eine vom Betriebssystem unabhängige GUI erzeugen kann.
   
4. Sie soll sehr leistungsfähig sein.
   Java hat aufgrund der Optimierungsmöglichkeit zur Laufzeit das Potenzial, eine bessere Performance als auf Compilezeit-Optimierungen begrenzte Sprachen (C++ und andere Sprachen) zu erreichen. Dem entgegen steht der Overhead durch die Laufzeitumgebung, sodass die Leistungsfähigkeit von beispielsweise C++-Programmen in einigen Kontexten übertroffen, in anderen aber nicht erreicht wird. Um die Leistungsfähigkeit zu gewährleisten, kann man in der Java Virtual Machine (JVM) die Performance messen.
   
5. Sie soll interpretierbar, parallelisierbar und dynamisch sein.
   Wie mehrfach erwähnt, finden die Kompilierung im maschinenunabhängigen Bytecode statt. Dieser wiederum kann auf der Zielplattform interpretiert werden. Die Java Virtual Machine interpretiert Bytecode, bevor sie es aus Performancegründen kompiliert und optimiert. Die Parallelisierbarkeit erreicht es durch die Unterstützung von Multithreading. Also durch den parallelen Ablauf von eigenständigen Programmabschnitten. Dazu bietet die Sprache selbst die Schlüsselwörter synchronized und volatile – Konstrukte, die das „Monitor & Condition Variable Paradigma“ von C. A. R. Hoare unterstützen. Die Klassenbibliothek enthält weitere Unterstützungen für parallele Programmierung mit Threads. Moderne JVMs bilden einen Java-Thread auf Betriebssystem-Threads ab und profitieren somit von Prozessoren mit multiplen Rechenkernen. Die Dynamik erreicht es durch den Aufbau. Vor allem durch die Dynamik bzw. der Anpassungsfähigkeit an sich ändernde Rahmenbedingungen anzupassen. Da die Module erst zur Laufzeit gelinkt werden, können beispielsweise Teile der Software (etwa Bibliotheken) neu ausgeliefert werden, ohne die restlichen Programmteile anpassen zu müssen. Man kann Interfaces als Basis für die Kommunikation zwischen zwei Modulen einsetzen, während sich die eigentliche Implementierung dynamisch und beispielsweise auch während der Laufzeit ändern kann.

Objektorientierung

Die Grundidee der objektorientierten Programmierung ist, Daten und zugehörige Funktionen möglichst eng in einem sogenannten Objekt zusammenzufassen und nach außen hin zu kapseln (Abstraktion). Die Absicht dahinter ist, große Softwareprojekte einfacher zu verwalten und die Qualität der Software zu erhöhen. Ein weiteres Ziel der Objektorientierung ist ein hoher Grad der Wiederverwendbarkeit von Softwaremodulen.

Ein neuer Aspekt von Java gegenüber beispielsweise der objektorientierten Programmiersprache C++ ist die explizite Unterscheidung zwischen Schnittstellen und Klassen, die man durch entsprechende Schlüsselwörter interface und class ausdrückt. Es unterstützt kein Erben von mehreren unabhängigen Basisklassen (sogenannte „Mehrfachvererbung“ wie in C++ oder Eiffel üblich), wohl aber das Implementieren einer beliebigen Zahl von Schnittstellen, womit sich viele der entsprechenden Probleme lösen lassen. Dabei kann man Methodensignaturen und Standardimplementierungen von Methoden an die abgeleiteten Klassen weitergeben, jedoch keine Attribute.

Es ist nicht vollständig objektorientiert, da die Grunddatentypen (int, boolean usw.) keine Objekte sind. Dies hängt mit der Syntax zusammen. Die Semantik, Grammatik und Syntax von Java sind in der Java Language Specification (Java-Sprachspezifikation) von Sun Microsystems dokumentiert. Das folgende Beispielprogramm gibt die unter Entwicklern bzw. Programmierern klassische Meldung „Hallo Welt!“, gefolgt von einem Zeilenumbruch, auf dem Ausgabemedium aus. Mittels Autoboxing kann man in die entsprechenden Objekttypen und umgekehrt umwandeln.

Reflexion

Reflexion (englisch reflection) bedeutet in der Programmierung, dass ein Programm die eigene Struktur kennt (englisch introspection) und/oder diese modifizieren kann (englisch intercession). Auch Java bietet eine Reflexion-API als Bestandteil der Laufzeitumgebung an. Damit ist es möglich, zur Laufzeit auf Klassen und Methoden zuzugreifen, deren Existenz oder genaue Ausprägung zur Zeit der Programmerstellung nicht bekannt war. Häufig wird diese Technik im Zusammenhang mit dem Entwurfsmuster Fabrikmethode (Factory Method) angewandt.

Annotationen

Annotationen erlauben die Notation von Metadaten und ermöglichen bis zu einem gewissen Grad benutzerdefinierte Spracherweiterungen. Sinn der Annotationen ist unter anderem die automatisierte Erzeugung von Code und anderen in der Software-Entwicklung wichtigen Dokumenten für wiederkehrende Muster anhand kurzer Hinweise im Quelltext. Früher hat man dafür ausschließlich Javadoc-Kommentare mit speziellen JavaDoc-Tags verwendet, deren Auswerung von Doclets wie zum Beispiel dem XDoclet stattgefunden hat.

Annotationen können auch in den kompilierten Class-Dateien enthalten sein. Für die Verwendung wird der Quelltext folglich nicht benötigt. Insbesondere sind die Annotationen auch über die Reflection-API zugänglich. Man kann sie beispielsweise zur Erweiterung des Bean-Konzeptes verwenden. Doch darüber schreibe ich in naher Zukunft einen gesonderten Beitrag.

Wo findet Java Einsatz?

Webanwendungen

Anwendungen, die man auf einem Webserver lädt, startet und die beim Benutzer in einem Webbrowser ablaufen bzw. dargestellt werden. Üblicherweise läuft ein Teil der Webanwendung auf dem Server (die Geschäftslogik und Persistenz) und ein anderer Teil im Webbrowser (die Logik der grafischen Benutzeroberfläche). Der Serverteil wird üblicherweise vollständig in Java geschrieben, der Browserteil üblicherweise in HTML und JavaScript. Es ist jedoch auch möglich, Java-Webanwendungen inklusive GUI-Logik vollständig in Java zu schreiben (siehe z. B. Google Web Toolkit oder die Remote Application Platform). Bekannte Beispiele für Java-Webanwendungen sind Twitter, Jira, Jenkins. Zwar nicht vollständig, aber Gmail ist zu großen Teilen auch damit geschrieben.

Desktop-Anwendungen

Unter Desktop-Anwendungen oder Applikationen fasst man normale Desktop-Programme zusammen. Sowohl Internet-Kommunikationsprogramme als auch Spiele und/oder Office-Anwendungen, die auf einem normalen PC laufen, haben diese Bezeichnung. Bekannte Beispiele für Java-Desktop-Anwendungen sind die integrierte Entwicklungsumgebung Eclipse oder das mittlerweile von Microsoft aufgekaufte Computerspiel Minecraft.

Applets

Java-Applets sind Anwendungen, die man normalerweise in einem Webbrowser ausführt. Sie sind üblicherweise auf einen durch ein spezielles HTML-Tag definierten Bereich einer Webseite beschränkt. Voraussetzung für die Ausführung der Applets ist ein Java-fähiger Browser. Eine Unterstützung dieser Anwendungsform liegt seit der Version 11 nicht mehr vor.

Apps

Apps sind kleinere Applikationen für mobile Endgeräte wie Handys, Smartphones, PDAs oder Tablets. Sie laufen üblicherweise auf speziellen, für die Ausführung von Java-Anwendungen optimierten Plattformen wie Java ME. Native Apps für das Android Betriebssystem von Google sind in der Regel auch damit programmiert, basieren aber auf einer abweichenden Klassenbibliotheks-API.

Entwicklungsumgebungen

Es gibt eine große Vielfalt von Entwicklungsumgebungen für Java, sowohl proprietäre als auch Open Source. Die meisten Entwicklungsumgebungen dafür sind selbst ebenfalls in Java geschrieben.

Die bekanntesten Open-Source-Umgebungen sind das von der Eclipse Foundation bereitgestellte Eclipse und das von Sun entwickelte NetBeans.

Unter den kommerziellen Entwicklungsumgebungen sind IntelliJ IDEA von JetBrains, siehe meinen Beitrag, JBuilder von Borland sowie JCreator und das auf NetBeans basierende Sun ONE Studio von Sun, am verbreitetsten. Außerdem gibt es noch eine Version von Eclipse, die von IBM unter dem Namen WebSphere Studio Application Developer („WSAD“) vertrieben wurde und ab Version 6.0 Rational Application Developer („RAD“) heißt. Auch in XCode von Apple lässt sich damit schreiben. Doch zu empfehlen ist es eher nicht, da es primär für C++ und C optimiert ist.

Sehr viele Texteditoren bieten Unterstützung dafür, darunter Emacs, jEdit, Atom (Ist aufgrund eines Hacks nicht mehr verfügbar 😉 ), Visual Studio Code, Vim und Notepad++, über die ich in zukünftigen Beiträgen schreibe.

Compiler

Ein Compiler übersetzt Java-Quellcode (Dateiendung „.java“) in einen ausführbaren Code. Grundsätzlich unterscheidet man zwischen Bytecode- und Nativecode-Compilern. Einige Laufzeitumgebungen verwenden einen JIT-Compiler, um zur Laufzeit den Bytecode häufig genutzter Programmteile in nativen Maschinencode zu übersetzen.

Bytecode Compiler

Im Normalfall übersetzt der Java-Compiler die Programme in einen nicht direkt ausführbaren Bytecode (Dateiendung „.class“), den die Java Runtime Environment (JRE) später ausführt. Die HotSpot-Technologie kompiliert den Bytecode zur Laufzeit in nativen Prozessorcode und optimiert diesen abhängig von der verwendeten Plattform. Diese Optimierung findet dabei nach und nach statt, sodass der Effekt auftritt, dass Programmteile nach mehrmaliger Abarbeitung schneller werden. Andererseits führt diese Technik, die ein Nachfolger der Just-in-time-Kompilierung ist, dazu, dass man mit Java-Bytecode, Anwendungen theoretisch genauso schnell wie nativ kompilierte Programme ausführen kann.

Native Compiler

Es existieren auch Compiler für Java, die Quelltexte oder den Bytecode in „normalen“ Maschinencode übersetzen können, sogenannte Ahead-of-time-Compiler. Nativ kompilierte Programme haben den Vorteil, keine JavaVM mehr zu benötigen aber auch den Nachteil, nicht mehr plattformunabhängig zu sein.

Beispiele für native Java Compiler waren Excelsior JET (eingestellt, bis Java SE 7), sowie GNU Compiler for Java (GCJ, eingestellt, bis J2SE 5.0) wie MinGW, Cygwin oder JavaNativeCompiler (JNC).

Wrapper

Als weitere Möglichkeit kann das Java-Programm in ein anderes Programm „eingepackt“ (englisch to wrap) werden. Unter anderem nennt man dies auch Adapter. Diese äußere Hülle dient dann als Ersatz für ein Java-Archiv. Sie sucht selbständig nach einer installierten Java-Laufzeitumgebung, um das eigentliche Programm zu starten und informiert den Benutzer darüber, wo er eine Laufzeitumgebung herunterladen kann, sofern noch keine installiert ist. Es ist also immer noch eine Laufzeitumgebung nötig, um das Programm starten zu können, aber der Anwender erhält eine verständliche Fehlermeldung, die ihm weiterhilft.

Java Web Start ist ein etwas eleganterer und standardisierter Ansatz für diese Lösung. Es ermöglicht die einfache Aktivierung von Anwendungen und garantiert, dass immer die neueste Version der Anwendung ausgeführt wird. Dadurch bleiben einem durch die Automatisierung komplizierte Installations- oder Aktualisierungsprozeduren erspart.

Beispiele für Java-Wrapper sind JSmooth oder Launch4J. JBuilder von Borland und NSIS sind ebenfalls in der Lage, einen Wrapper für Windows zu erstellen.

Fazit

Ein Fazit gibt es hierfür nicht, da ich es mir nicht anmaße, etwas zu beurteilen, dass ich noch nicht zu einem großen Teil verstehe. In diesem Zusammenhang vielleicht in den zukünftigen Beiträgen zu finden.

Der Beitrag Java – Endlose Möglichkeiten der Softwareentwicklung erschien zuerst auf CEOsBay.

Cucumber wurde ursprünglich in der Programmiersprache Ruby für Ruby-Anwendungen geschrieben. In der Zwischenzeit unterstützt es aber auch andere Programmiersprachen wie Java und alle anderen auf der Java Virtual Machine gängigen Programmiersprachen sowie C++ und JavaScript. Darüber hinaus gibt es Projekte, die Cucumber noch für weitere Programmiersprachen zur Verfügung stellen und sich als Teil der Cucumber-Familie sehen. Darunter beispielsweise SpecFlow, eine Implementierung für C#.

Wie funktioniert Cucumber?

Wie auch bei den meisten anderen BDD-Frameworks werden in Cucumber Funktionalitäten mittels der Beschreibungssprache „Gherkin“ beschrieben. Gherkin verwendet natürliche Schriftsprache als Grundlage. Lediglich bestimmte Schlüsselwörter werden besonders behandelt.

Gherkin

Gherkin ist die Sprache, die Cucumber verwendet, um Testfälle zu definieren. Sie ist so konzipiert, dass sie sich nicht-technisch und für den Menschen lesbar gestaltet. Es beschreibt Anwendungsfälle in Bezug auf ein Softwaresystem. Der Zweck hinter der Gherkin-Syntax ist die Förderung verhaltensorientierter Entwicklungspraktiken in einem Entwicklungsteam, einschließlich Geschäftsanalysten und Managern. Sie zielt darauf ab, bereits in den ersten Phasen der Anforderungsdefinition durch die Geschäftsleitung und in anderen Phasen des Entwicklungslebenszyklus einer Anwendung feste, eindeutige Anforderungen durchzusetzen.

Syntax

Die Syntax ist ähnlich wie bei Python zeilenorientiert aufgebaut. Die Struktur einer Datei wird durch Leerzeichen und andere Steuerzeichen definiert. # wird als Zeilen bzw. Kommentarzeichen verwendet und kann an jeder beliebigen Stelle in einer Datei stehen. Anweisungen sind jede nicht leere und nicht kommentierte Zeile. Sie bestehen aus einem konkreten Gherkin-Schlüsselwort, gefolgt von einer Zeichenkette.

Alle Gherkin-Dateien haben die Dateierweiterung .feature. Sie enthalten eine einzelne Feature-Definition für das zu testende System und sind ein ausführbares Testskript.

Neben der Bereitstellung eines Skripts für automatisierte Tests ist die Syntax von Gherkin so konzipiert, dass sie eine einfache Dokumentation des zu testenden Codes ermöglicht. Gherkin unterstützt derzeit Schlüsselwörter in Dutzenden von Sprachen.

Schlüsselwörter der Gherkin Sprache

• Feature: Name bzw. die Bezeichnung des Features
• Rule: Regeln des Features
• Example oder Scenario: Die Bezeichnung des Szenarios (Beispielsweise „Die erfolgreiche Anmeldung mit gültigen Anmeldeinformationen.“)
• Given, When, Then, And, But für die steps (oder *)- Vorbedingungen (Gegeben sei), die Aktion, die ausgeführt wird bzw. die Erweiterung durch andere Schlüsselwörter um die Aktion die ausgeführt wird zu ergänzen bzw. zu erweitern. (Der User gibt beispielsweise seine Zugangsdaten, Username and Password ein), gefolgt von der erwarteten Reaktion des Systems (Beispielsweise die Nachricht, bei einem erfolgreichen Login.)
• Background – Ein Background ermöglicht es einem, den nachfolgenden Scenarios einen gewissen Kontext hinzuzufügen. Es kann einen oder mehrere Vorgegebene Schritte enthalten, die vor jedem Scenario aber nach jedem Before hook ausgeführt werden.
• Scenario Outline oder Scenario Template – Damit lässt sich dasselbe Szenario mehrmals mit unterschiedlichen Wertekombinationen ausführen.
• Examples oder Scenarios – Eine Scenario Outline muss einen oder mehrere Abschnitte mit Examples bzw. Scenarios enthalten. Sie dienen als Steps bzw. Interpretationsvorlage, die nie direkt ausgeführt werden. Stattdessen wird die Szenariogliederung einmal für jede Zeile mit den darunter liegenden Abschnitten von Examples ausgeführt.

Gherkin in deutscher Sprache

Um eine Funktionalität auf Deutsch zu schreiben, muss am Beginn des Features # language: de angegeben werden. Damit sind u.A. folgende deutsche Schlüsselwörter verfügbar:

• Funktionalität
• Grundlage
• Szenario
• Szenariogrundriss
• Beispiele
• Angenommen
• Gegeben sei
• Wenn
• Dann
• Und und Aber, sowie *

Die Command line (CL)

Cucumber verfügt über eine integrierte Kommandozeilenschnittstelle, die eine umfassende Liste von Anweisungen enthält. Wie die meisten Kommandozeilen-Tools bietet Cucumber die Option –help an, die eine Zusammenfassung der Befehle liefert, die diese Command Line akzeptiert.

$ cucumber --help
        -r, --require LIBRARY|DIR        Require files before executing the features.
        --i18n LANG                      List keywords for in a particular language.
                                         Run with "--i18n help" to see all languages.
        -f, --format FORMAT              How to format features (Default: pretty).
        -o, --out [FILE|DIR]             Write output to a file/directory instead of
        ...

Fazit

Gherkin ist nicht nur zum Schreiben von automatisierten Tests geeignet. Man kann Gherkin grundsätzlich auch dazu verwenden, um strukturierte Tests zu erstellen, die man später als Projektdokumentation verwendet kann. Erst die Eigenschaft, strukturiert zu sein, gibt uns die Möglichkeit zu automatisieren.

Sowohl die Sprache Gherkin wie auch das Tool Cucumber, bieten weitaus mehr Funktionalitäten, die ich hier nicht thematisiert habe. Zumal ich auch recht frisch in dieses Thema eingestiegen bin. So ist beispielsweise ein Datengetriebenes Szenario mithilfe von Tabellen möglich. Fernab können verschiedene Schritte, die im Prinzip das Gleiche tun, über Platzhalter definiert werden.

Um solche und weitere Vorteile zu nutzen, ist neben Cucumber oder anderen Testtools vor allem Disziplin beim Verfassen der Dokumentation bzw. der Gherkin Dokumente gefragt. Gleichzeitig müssen die formulierten Schritte präzise genug sein, um die gewünschten Verhaltensweisen ausreichend genau zu beschreiben. Ansonsten zerfällt die Abstraktion und Gherkin Dokumente werden lediglich zu etwas besser lesbaren Testskripten statt dem Ansatz des BDD zu folgen.

Cucumber lässt sich auch mit IntelliJ nutzen. Aber darüber gibt es dann in naher Zukunft einen weiteren Beitrag.

Der Beitrag Cucumber – Das kollaborative Tool für Behavior Driven Development erschien zuerst auf CEOsBay.