Geschichte von Mockito

Mockito trat in der Java-Community erstmals 2007 in Erscheinung und stammt von Szczepan Faber. Faber’s Ziel: Ein einfacheres und effektiveres Tool als die damals verfügbaren Mocking-Frameworks erschaffen. Die Hauptziele waren Klarheit, Einfachheit und die Vermeidung von redundanter Testcode-Erstellung. Dank dieser Prinzipien hat es sich schnell zu einem der beliebtesten Mocking-Frameworks für Java entwickelt.

Grundlagen und Einrichtung von Mockito

Mockito ist ein Java-basiertes Framework, dass es Entwicklern ermöglicht, externe Abhängigkeiten in Unit-Tests zu simulieren. Damit kann man sicherstellen, dass der zu testende Code korrekt funktioniert, ohne sich auf externe Faktoren zu verlassen. Hier geht es zu der offiziellen Website.

Zur Integration in ein Java-Projekt empfiehlt sich die Verwendung von Build-Tools wie Maven oder Gradle. Für Maven kann die folgende Dependency in die pom.xml (Siehe auch meinen Beitrag über XML) eingefügt werden:

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>3.x.x</version>
    <scope>test</scope>
</dependency>

Best Practices für die Verwendung von Mockito

1. Vermeide any() wo möglich: Es kann verlockend sein, den any()-Matcher von Mockito zu verwenden, um alle möglichen Eingaben abzudecken. Allerdings kann dies zu ungenauen Tests führen. Stattdessen sollte man versuchen, genaue Matcher oder konkrete Werte zu verwenden.
2. Nutze verify() zur Überprüfung der Interaktion: Mit verify() kann man den Abruf einer bestimmten Methode auf einem Mock-Objekt überprüfen. Dies stellt sicher, dass die erwarteten Interaktionen tatsächlich stattfinden.

Mockito.verify(mockObjekt).methode();

3. Bevorzuge thenReturn() gegenüber thenAnswer(): Wenn es nicht notwendig ist, auf die konkreten Argumente einer Methode zuzugreifen, sollte man thenReturn() verwenden, da es den Testcode sauberer und verständlicher macht.

Mockito.when(mockObjekt.methode()).thenReturn(wert);

Fazit

Mockito hat sich als unverzichtbares Tool in der Java-Entwicklungslandschaft etabliert. Durch die Fähigkeit, komplexe externe Abhängigkeiten zu simulieren, ermöglicht es präzise und zuverlässige Unit-Tests. Bei der Verwendung sollte man immer darauf achten, klaren und präzisen Testcode zu schreiben, um die Vorteile des Frameworks voll auszuschöpfen.

Ein gezieltes Verständnis und die richtige Anwendung von Mockito in Java-Projekten können die Qualität der Software maßgeblich beeinflussen und sicherstellen, dass sie den gewünschten Anforderungen entspricht.

Der Beitrag Mockito – Framework für Unit-Tests in Java erschien zuerst auf CEOsBay.

Was ist der Playwright Trace-Viewer?

Der Playwright Trace-Viewer bietet Entwicklern und Testern die Möglichkeit, eine visuelle Repräsentation ihrer Testsitzungen anzuzeigen. Bei der Arbeit mit Playwright zeichnet dieses Tool automatisch jede Aktion auf, die während des Testlaufs durchgeführt wird. Dazu gehören beispielsweise Mausklicks, Tastatureingaben oder Netzwerkanfragen. Der Trace-Viewer visualisiert dann diese aufgezeichneten Aktionen, was den Testern hilft, Fehler schneller zu identifizieren und zu beheben.

Entstehungsgeschichte des Trace-Viewers

Playwright, ein Open-Source–Framework für das Browser-Testing, entstand als Projekt von Microsoft. Durch die wachsende Popularität von Playwright erkannte das Entwicklerteam die Notwendigkeit, die Fehlerbehebung während des Testprozesses zu erleichtern. So entstand der Trace-Viewer – ein Tool, das die Transparenz im Testprozess erhöht und die Qualitätssicherung revolutioniert.

Einrichtung und Verwendung Playwright Trace-Viewer

1. Installation von Playwright: Installiert Playwright mit dem folgenden Befehl:

npm install playwright

2. Aufnahme eines Traces: Bei der Ausführung eines Playwright-Tests verwendet man die Option --trace:

npx playwright test --trace

Dies erzeugt eine Trace-Datei im voreingestellten Verzeichnis.

3. Anzeige des Traces: Nach Abschluss des Tests öffnet man den Trace-Viewer mit:

npx playwright show-trace [path-to-trace.zip]

Darauf sollte man beim Umgang mit dem Trace-Viewer achten

• Speicherplatz: Traces können viel Speicherplatz beanspruchen. Überlegt, ob ständige Aufzeichnungen notwendig sind oder ob gezielte Tests ausreichen.
• Datenschutz: Der Trace-Viewer kann sensible Daten erfassen. Stellt sicher, dass persönliche Daten vor der Speicherung oder Weitergabe anonymisiert werden.
• Performance: Die ständige Aufzeichnung kann die Performance beeinträchtigen. Ein gezielter Einsatz von Tracing minimiert diesen Effekt.

Fazit

Der Playwright Trace-Viewer stellt eine unschätzbare Ressource für Tester und Entwickler dar. Er verbessert nicht nur die Fehlererkennung, sondern auch das Verständnis für die Abläufe während des Testens. Durch die effiziente Nutzung dieses Tools können Entwicklungs- und Testteams produktiver arbeiten und hochwertige Webanwendungen liefern.

Der Beitrag Playwright Trace-Viewer – Vom Code zum Klarblick erschien zuerst auf CEOsBay.

PlayWright stellt ein modernes Open-Source–Framework dar, welches Entwicklern ermöglicht, End-to-End-Tests für Webanwendungen in verschiedenen Browsern zu schreiben und durchzuführen. Hierzu zählen populäre Browser wie Chrome, Firefox, Edge und Safari. Das Framework besticht durch seine Funktionalität, Webanwendungen in einer realitätsgetreuen Umgebung zu testen und dabei Aktionen wie Klicks, Tastatureingaben und Seitennavigationen zu simulieren.

Die Entstehung von PlayWright

Das Team hinter Microsofts Edge-Browser hat PlayWright ins Leben gerufen. Dieses Framework knüpft an den Erfahrungen und Lektionen aus früheren Projekten wie Puppeteer an. Ziel dabei war es, ein Tool zu schaffen, das die neuesten und fortschrittlichsten Funktionen der Webplattformen unterstützt und den Entwicklern eine beispiellose Testabdeckung bietet.

PlayWright aufsetzen: Ein einfacher Leitfaden

Die Einrichtung gestaltet sich unkompliziert und schnell:

1. Installation via npm: Um PlayWright zu installieren, nutzt man einfach den Befehl:
   npm i playwright

2. Erster Testscript: Nach der Installation kann man direkt einen ersten Testscript schreiben.
   Zum Beispiel:
   

   const { chromium } = require('playwright'); 
   (async () => { 
       const browser = await chromium.launch(); 
       const page = await browser.newPage(); 
       await page.goto('https://example.com'); 
       await page.screenshot({ path: 'screenshot.png' }); 
       await browser.close(); 
   })(); 

   Dieses Skript startet den Chromium-Browser, öffnet eine neue Seite, navigiert zur angegebenen URL und erstellt einen Screenshot.
   
3. Ausführung: Nach dem Speichern des Skripts führt man es einfach über die Kommandozeile mit Node.js aus.

Wichtige Begriffe in Playwright

1. Playwright:
   – Die Hauptschnittstelle in Playwright.
   – Bietet Methoden zum Starten von Browser-Instanzen.
2. BrowserType:
   – Eine Schnittstelle, die Methoden zum Starten oder Verbinden mit spezifischen Browser-Instanzen bereitstellt.
3. Browser:
   – Wird über BrowserType.launch() erstellt.
   – Repräsentiert eine Browser-Instanz.
4. BrowserContext:
   – Ein Container für Browsersitzungen, der unabhängige Sitzungen ermöglicht.
   – Erlaubt den Betrieb mehrerer Sitzungen in einer einzelnen Browser-Instanz.
5. Page:
   – Repräsentiert eine Webseite oder einen Browsertab.
   – Bietet Methoden zur Interaktion mit der Seite; eine Browser-Instanz kann mehrere Seiten handhaben.
6. Locator:
   – Zentrale Komponente für Playwrights automatisches Warten und Wiederholungslogik.
   – Wird verwendet, um Elemente auf der Seite zu finden und mit ihnen zu interagieren.
   – Erstellt über die Methode Page.locator().

Best Practices und Tipps zur Implementierung

• Warteoperationen vermeiden: Anstelle von festen Wartezeiten setzt man auf PlayWrights integrierte waitFor-Funktionen, um sicherzustellen, dass Elemente vorhanden sind oder bestimmte Zustände erreicht sind.
• Isolierte Tests schreiben: Jeder Test sollte unabhängig voneinander laufen können, um Seiteneffekte zu vermeiden.
• Verwende Page-Objekte: Die Verwendung von Page-Objekten hilft dabei, den Code sauber und wartbar zu halten, indem man die Interaktionen mit der Webseite kapselt.

Vorteile von PlayWright:

1. Mehrere Browser: Es unterstützt Tests in mehreren Browsern, einschließlich Chrome, Firefox, Edge und Safari, wodurch eine breitere Abdeckung und Kompatibilitätsprüfung ermöglicht wird.
2. Schnelligkeit: Es bietet eine schnelle Ausführungsgeschwindigkeit für Tests, was die Entwicklungseffizienz erhöht.
3. Zuverlässigkeit: Mit Funktionen wie automatischer Warteunterstützung reduziert PlayWright flüchtige Fehler und steigert die Zuverlässigkeit der Tests.
4. Modernes API-Design: Die API ist intuitiv und einfach zu verwenden, was die Lernkurve für Entwickler verkürzt.
5. Mobile Emulation: Es ermöglicht das Testen von mobilen Ansichten durch Emulation, was besonders nützlich ist, um responsive Designs zu überprüfen.
6. Erweiterte Funktionen: PlayWright bietet Funktionen wie die Interaktion mit Shadow DOM, das Erfassen von Netzwerkanfragen und die Arbeit mit WebSockets.
7. Aktive Gemeinschaft und Unterstützung: Mit einer aktiven Entwicklergemeinschaft und Unterstützung durch Microsoft ist PlayWright ständig im Wachstum und in der Entwicklung.

Nachteile von PlayWright:

1. Jünger als einige Alternativen: Es ist jünger als einige seiner Konkurrenten wie Selenium, was bedeutet, dass es vielleicht nicht so bekannt oder weit verbreitet ist.
2. Kompatibilität: Während PlayWright viele moderne Webfunktionen unterstützt, gibt es möglicherweise ältere Funktionen oder spezifische Framework-Interaktionen, die es noch nicht vollständig handhabt.
3. Ressourcenverbrauch: Bei intensiven Testsitzungen kann es mehr Systemressourcen verbrauchen, insbesondere wenn gleichzeitig in mehreren Browserinstanzen getestet wird.
4. Lernkurve: Trotz eines intuitiven API-Designs kann es für Entwickler, die von anderen Testwerkzeugen wechseln, eine gewisse Eingewöhnungszeit erfordern.

Es ist wichtig zu beachten, dass die Vor- und Nachteile von der spezifischen Anwendung und den Anforderungen des Projekts abhängen können. Das Auswählen des richtigen Tools erfordert oft eine sorgfältige Überlegung und Bewertung im Kontext des Projekts.

Fazit

PlayWright bietet Entwicklern ein kraftvolles Tool, um End-to-End-Tests für Webanwendungen in verschiedenen Browsern zu erstellen und durchzuführen. Mit der Unterstützung von Microsoft und einer aktiven Community hinter sich, hat sich PlayWright rasch zu einem bevorzugten Tool in der Entwicklergemeinschaft entwickelt. Mit den genannten Tipps und Best Practices steht einem effektiven und effizienten Testen nichts mehr im Wege.

Der Beitrag Playwright – Testen ohne Grenzen erschien zuerst auf CEOsBay.

Was ist der Systemtest im Software Testing?

Im Kontext des Software Testings ist der Systemtest eine Teststufe, bei der man das komplette und vollintegrierte Softwareprodukt testet. Dabei prüft man, ob das System als Ganzes die spezifizierten Anforderungen erfüllt und ob alle Komponenten effizient zusammenarbeiten. Neben funktionalen Aspekten beinhaltet der Systemtest auch nicht-funktionale Aspekte wie Leistung, Sicherheit und Benutzerfreundlichkeit.

Systemtests unterscheiden sich von anderen Teststufen, insbesondere von den Unit-Tests und Integrationstests, in ihrem Fokus. Während Unit-Tests einzelne Softwarekomponenten (z.B. Funktionen oder Methoden) testen und Integrationstests die korrekte Interaktion von Komponenten überprüfen, konzentriert sich der Systemtest auf das gesamte Softwareprodukt.

Kurze Zeitreise und ein historischer Überblick über den Systemtest

Die genaue Herkunft des Systemtests als Testmethode lässt sich schwer auf eine einzelne Person oder ein bestimmtes Ereignis zurückführen. Es ist jedoch allgemein anerkannt, dass die Praxis des Software Testings und insbesondere der Systemtests mit der Entwicklung der Softwaretechnik einherging.

In den frühen Tagen der Computertechnik, als man Software noch von Hand mittels Lochkarten programmierte, gab es wenig Bedarf für systematische Tests. Fehler wurden oft „on-the-fly“ während des Betriebs behoben. Mit zunehmender Komplexität der Software und der Entwicklung von höheren Programmiersprachen wurde jedoch ein systematischer Ansatz zur Fehlervermeidung und -erkennung notwendig.

Einen wichtigen Meilenstein für die Entwicklung des Software Testings stellt das Jahr 1972 dar. In diesem Jahr veröffentlichte die US-amerikanische Software-Ingenieurin und Computerwissenschaftlerin Glenford J. Myers das Buch „The Art of Software Testing“, das als eines der ersten umfassenden Werke zum Thema Software Testing gilt. Auch wenn man Myers nicht explizit als „Erfinder“ der Systemtests bezeichnen kann, so hat doch seine Arbeit maßgeblich dazu beigetragen, das Bewusstsein für die Notwendigkeit des Software Testings und die Entwicklung von standardisierten Testverfahren zu schärfen.

Aktueller Stand der Systemtests

Die Praxis des Systemtests hat sich in den letzten Jahrzehnten weiterentwickelt und professionalisiert. Die Einführung von agilen Methoden in der Softwareentwicklung und das Aufkommen von DevOps haben die Art und Weise, wie Software getestet wird, verändert und den Systemtest weiter in den Mittelpunkt gerückt. Heute ist der Systemtest ein integraler Bestandteil jedes seriösen Softwareentwicklungsprozesses.

Aktuell gibt es verschiedene Tools und Frameworks zur Unterstützung von Systemtests. Dazu gehören sowohl kommerzielle Lösungen als auch Open-Source-Werkzeuge. Mit deren Hilfe kann man Tests automatisiert durchführen und Testergebnisse dokumentieren.

Welche Software-Lösungen gibt es?

Selenium, ein Open-Source–Framework für automatisiertes Testen, JUnit, ein Framework zum Testen von Java-Anwendungen, TestComplete, eine kommerzielle Lösung für automatisiertes Testen, Postman, ein Tool für API-Tests, LoadRunner, eine kommerzielle Lösung für Leistungs- und Lasttests, und Appium, ein Open-Source-Tool für das automatisierte Testen von mobilen Anwendungen.

Fazit

Im Hinblick auf die Zukunft ist zu erwarten, dass die Bedeutung des Systemtests weiter zunehmen wird. Insbesondere vor dem Hintergrund der fortschreitenden Digitalisierung und der damit einhergehenden Komplexität von Software werden zuverlässige und effiziente Testverfahren immer wichtiger.

Insgesamt trägt der Systemtest dazu bei, die Qualität von Software zu sichern und eine zuverlässige und effiziente Leistung des Softwareprodukts zu gewährleisten. Dabei hat er sich seit seinen Anfängen stetig weiterentwickelt und wird auch in Zukunft ein zentraler Bestandteil des Software Testings bleiben.

Der Beitrag Systemtest – Im Software Testing erschien zuerst auf CEOsBay.

Kurze Zeitreise

Die Geschichte von C# beginnt im Jahr 1999. Als Microsoft-Entwickler Anders Hejlsberg und sein Team an einer neuen Programmiersprache namens „Cool“ (kurz für „C-like Object Oriented Language“) arbeiteten. Das Projekt, Teil von Microsofts größerer .NET-Initiative, eine einheitliche Plattform für die Entwicklung von Webdiensten, Desktop-Anwendungen und verteilter Systeme zu schaffen. Cool sollte leistungsstark und einfach zu erlernen sein. Die Elemente von C, C++, Java und Delphi in einer Programmiersprache vereint.

Die ersten Schritte (2000-2002)

Im Juni 2000 kam die offizielle Vorstellung von Microsoft C#. Es war von Anfang an eng mit dem .NET-Framework verknüpft. Die Veröffentlichung der ersten Version von C# und dem .NET-Framework (Version 1.0) folgte im Jahr 2002. Sie bot grundlegende Funktionen für objektorientierte Programmierung, wie Klassen, Objekte, Vererbung und Polymorphismus. Auch wenn diese Version noch nicht über einige der leistungsfähigen Funktionen verfügte, die man in späteren Versionen hinzugefügte. War es dennoch eine attraktive Option für Entwickler, die eine Alternative zu Java oder C++ suchten.

Weiterentwicklung und Verbesserungen (2002-2010)

In den folgenden Jahren entwickelte sich C# kontinuierlich weiter, zahlreiche neue Funktionen und Verbesserungen kamen nach und nach hinzu. C# 2.0, dessen Veröffentlichung im Jahr 2005 stattfand, führte Generics, partielle Klassen, anonyme Methoden und Nullable-Werttypen ein. Diese Verbesserungen erleichterten die Programmierung und erweiterten die Möglichkeiten von C# erheblich.

C# 3.0 dann im Jahr 2007. Es brachte eine der bahnbrechendsten Neuerungen der Sprache: Language Integrated Query (LINQ) ins Spiel. LINQ ist eine Sammlung von Funktionen, die es ermöglichen, Daten aus verschiedenen Quellen (wie SQL-Datenbanken, XML-Dokumenten und in-memory Kollektionen) zu verarbeiten. Direkt in C#, und außerdem, zu manipulieren. Diese Version führte auch anonyme Typen, Erweiterungsmethoden und Lambda-Ausdrücke ein, was die Sprache noch flexibler und ausdrucksstärker machte.

Mit C# 4.0, das 2010 erschien, kamen einige wichtige Funktionen hinzu. Diese verbesserten die Interoperabilität von C# mit anderen Technologien und Programmiersprachen. Dazu gehörten dynamische Typen, benannte und optionale Parameter sowie verbesserte COM-Interoperabilität.

Aktuelle Entwicklungen (2010-heute)

C# 5.0, im Jahr 2012. Es fokussierte sich hauptsächlich auf die Verbesserung der asynchronen Programmierung durch die Einführung von Async und Await Keywords. Diese Funktionen ermöglichen es Entwicklern, heute noch, asynchronen Code auf einfache und saubere Weise zu schreiben. So kann man Anwendungen erstellen, die dadurch heute schneller und reaktionsfähiger sind.

Seitdem kamen weitere Versionen von C#, die jeweils neue Funktionen und Verbesserungen enthielten. C# 6.0 (2015) brachte einige Syntaktische Vereinfachungen wie Auto-Property-Initialisierer, Expression-bodied-Mitglieder, Nullbedingungsoperator (?.) und String-Interpolation.

Gefolgt von C# 7.0 (2017). Es kamen Tuples, Pattern Matching, lokale Funktionen und erweiterte Möglichkeiten für das Arbeiten mit Werttypen durch die Einführung von ref locals und ref returns mit rein.

Und C# 8.0 (2019) legte einen Schwerpunkt auf die Verbesserung von Sicherheit und Produktivität, indem es Funktionen wie Nullable Reference Types, Asynchronous Streams, Pattern Matching Enhancements, Indices und Ranges sowie Default Interface Members einführte.

Zuletzt C# 9.0 im Jahr 2020, dass sich auf die Verbesserung von Programmiersprachfunktionen konzentrierte. Dadurch konnte man den Umgang mit Daten und den Ausdruck von Algorithmen vereinfachen. Dazu gehörten beispielsweise Init-only-Properties, Records, Pattern Matching Enhancements, Top-Level-Statements und Target-typed New Expressions.

Parallel zur Entwicklung von C# hat Microsoft auch an der .NET-Plattform gearbeitet. Im Jahr 2016 veröffentlichte das Unternehmen .NET Core, eine plattformübergreifende, modulare und leichte Version von .NET, die für moderne Web- und Cloud-Anwendungen optimiert ist. Seit der Veröffentlichung von .NET 5 im Jahr 2020 hat Microsoft die traditionellen .NET-Frameworks und .NET Core vereint und setzt nun auf eine einzige .NET-Laufzeit und -Plattform.

Vorteile von C#

• Vielseitigkeit: Es eignet sich für eine breite Palette von Anwendungen und Projekten. Es wird häufig für die Entwicklung von Webanwendungen, Windows-Anwendungen, Cloud-basierten Diensten, Spielen, mobilen Anwendungen und sogar KI-Projekten verwendet.
• Objektorientierung: Es ist eine vollständig objektorientierte Sprache, was bedeutet, dass sie auf dem Prinzip der Kapselung von Daten und Verhalten innerhalb von Objekten basiert. Dies ermöglicht eine saubere Trennung von Anliegen und fördert Wiederverwendbarkeit und Erweiterbarkeit des Codes.
• Einfache und klare Syntax: Die Syntax von C# ist einfach und leicht verständlich, wodurch Programmierer schneller lernen und produktiver sein können. Die Sprache ist weniger fehleranfällig und erlaubt Entwicklern, effizienter und mit weniger Fehlern zu arbeiten.
• Leistungsstarke Entwicklungsumgebungen: C# wird von einer Vielzahl von Entwicklungsumgebungen unterstützt, insbesondere von Visual Studio Code, einer leistungsstarken integrierten Entwicklungsumgebung (IDE) von Microsoft. Dies ermöglicht Programmierern, schnell und effizient zu arbeiten, Code zu schreiben, zu testen und zu debuggen.
• Unterstützung und Gemeinschaft: Da C# von Microsoft entwickelt und unterstützt wird, profitiert die Sprache von einer starken Gemeinschaft und einer breiten Palette von Ressourcen, einschließlich Online-Tutorials, Dokumentationen und Foren. Die C#-Community ist bekannt für ihre Hilfsbereitschaft und ihr Engagement, neue Programmierer willkommen zu heißen und bei Problemen zu unterstützen.
• Interoperabilität: C# bietet eine hervorragende Interoperabilität mit anderen .NET-Sprachen und -Technologien. Durch die Nutzung der .NET-Bibliotheken und –Frameworks können Entwickler eine Vielzahl von Funktionalitäten in ihren Anwendungen leicht implementieren und erweitern.
• Skalierbarkeit und Leistung: C#-Anwendungen sind für ihre Leistung und Skalierbarkeit bekannt. Durch die Verwendung des Just-In-Time (JIT)-Compilers und anderer Optimierungstechniken bietet C# schnelle Ausführungszeiten und geringe Latenzzeiten, was für Anwendungen mit hohen Anforderungen an Geschwindigkeit und Reaktionsfähigkeit unerlässlich ist.
• Plattformübergreifende Entwicklung: Mit der Einführung von .NET Core und Xamarin ermöglicht C# die plattformübergreifende Entwicklung von Anwendungen für Windows, MacOS, Linux, iOS und Android. Dies eröffnet Entwicklern eine Vielzahl neuer Möglichkeiten und macht die Sprache noch attraktiver für Unternehmen und Entwickler.

Nachteile von C#

Obwohl es eine leistungsstarke und vielseitige Programmiersprache ist, gibt es einige Nachteile, die man beachten sollte, bevor man sich für diese Sprache entscheidet. Hier sind einige der wichtigsten:

• Leistung: Trotz der Verbesserungen in der Laufzeitumgebung und den Optimierungstechniken von .NET ist die Leistung von C#-Anwendungen möglicherweise nicht so gut wie die von Anwendungen, die in niedrigeren Programmiersprachen wie C oder C++ geschrieben sind. Die Verwendung von Just-In-Time (JIT)-Kompilierung und Garbage Collection kann zu einem gewissen Laufzeit-Overhead führen.
• Plattformabhängigkeit: Historisch gesehen war C# stark an das Windows-Ökosystem und die .NET-Plattform gebunden. Obwohl die Einführung von .NET Core und Xamarin die plattformübergreifende Entwicklung ermöglicht hat, ist die Unterstützung und Integration von C# in Nicht-Windows-Umgebungen möglicherweise nicht so nahtlos wie bei einigen anderen Programmiersprachen, insbesondere Java. Mir ist dies besonders aufgefallen, als ich zeitgleich für Android und iOS Devices kompiliert habe. Man muss einige Dinge beachten und Drittanbieter-Software installieren, um überhaupt vom Fleck zu kommen.
• Lernkurve: Obwohl es im Vergleich zu einigen anderen Programmiersprachen relativ einfach zu erlernen ist, kann es dennoch eine gewisse Zeit dauern, sich mit allen Funktionen und Konzepten der Sprache vertraut zu machen, insbesondere wenn man noch keine Erfahrung mit objektorientierter Programmierung hat.
• Größe des Ökosystems: Während das .NET-Ökosystem umfangreich ist und viele Bibliotheken und Frameworks bietet, kann es sein, dass bestimmte Drittanbieter-Bibliotheken oder -Tools nicht verfügbar sind oder nicht so umfangreich wie in einigen anderen Programmiersprachen.
• Proprietäre Natur: C# von Microsoft ist eine proprietäre Sprache. Obwohl es Open-Source-Implementierungen gibt (z.B. .NET Core und Xamarin), hängt die Entwicklung der Sprache und der zugehörigen Tools stark von Microsofts Strategie und Vision ab. Einige Entwickler ziehen es vor, sich auf Open-Source-Programmiersprachen wie Python oder Java zu konzentrieren, die nicht ein einzelnes Unternehmen kontrolliert.

Anwendungsbeispiele für C#

• Webanwendungen: Es ist eine beliebte Wahl für die Entwicklung von Webanwendungen, insbesondere mit dem ASP.NET-Framework. ASP.NET Core ist ein Open-Source-Webframework, das auf .NET Core basiert und die Entwicklung von modernen, leistungsstarken Webanwendungen ermöglicht.
• Windows-Anwendungen: Es eignet sich hervorragend für die Entwicklung von Windows-Desktop-Anwendungen. Mit dem Windows Presentation Foundation (WPF) Framework können Entwickler ansprechende Benutzeroberflächen und robuste Anwendungen erstellen.
• Mobile Anwendungen: Mit Hilfe von Xamarin, einer plattformübergreifenden App-Entwicklungsumgebung, können Entwickler C# verwenden, um native Anwendungen für iOS, Android und Windows Mobile zu erstellen.
• Spieleentwicklung: Die Unity-Engine, eine der weltweit führenden Spieleentwicklungsplattformen, unterstützt C# als Skriptsprache. Dies ermöglicht es Entwicklern, anspruchsvolle und leistungsfähige Spiele für verschiedene Plattformen zu entwickeln.

Fazit:

C# hat sich seit seiner Einführung zu einer der bevorzugten Programmiersprachen für Entwickler und Unternehmen entwickelt. Mit seiner Vielseitigkeit, leistungsstarken Entwicklungsumgebungen, der starken Unterstützung durch Microsoft und einer engagierten Community bietet C# eine hervorragende Grundlage für die Entwicklung einer Vielzahl von Anwendungen. Wenn man in Betracht zieht, eine neue Programmiersprache zu erlernen oder ein neues Projekt zu starten, sollte man auf jeden Fall die vielen Vorteile von C# in Betracht ziehen.

Der Beitrag C# – Als Brücke zwischen Innovation und Benutzererfahrung erschien zuerst auf CEOsBay.

Hauptmerkmale von Vue.js

• Leichtgewichtig und Modularität: Vue.js ist für seine geringe Größe bekannt, wobei die kompilierte und gzip-komprimierte Version gerade einmal 20 KB wiegt. Das Framework ist in verschiedene Module unterteilt, sodass Entwickler nur diejenigen auswählen müssen, die sie für ihr Projekt benötigen, um den Overhead gering zu halten.
• Progressive Anpassung: Vue.js ist als progressives Framework konzipiert, was bedeutet, dass man es schrittweise in bestehende Projekte implementieren kann. Es ermöglicht Entwicklern, bestehenden Anwendungen schrittweise Verbesserungen hinzuzufügen, ohne die gesamte Anwendung neu schreiben zu müssen.
• Reaktive Datenbindung: Eine der Hauptstärken von Vue.js ist die reaktive Datenbindung. Dies bedeutet, dass die Übertragung aller Änderungen auf die Benutzeroberfläche automatisch stattfindet, ohne dass der Entwickler explizit eingreifen muss.
• Single-File-Komponenten: Vue.js bietet eine einfache Möglichkeit, wiederverwendbare Komponenten zu erstellen, indem HTML, JavaScript und CSS via Kapselung in einer einzigen .vue-Datei zusammengefasst sind. Diese Tatsache vereinfacht die Strukturierung und Wartung von Projekten maßgeblich.
• Declarative Rendering: Mit Vue.js können Entwickler deklarativ angeben, wie die Anwendung auf der Grundlage der zugrunde liegenden Daten rendert. Diese Herangehensweise verbessert die Lesbarkeit und Wartbarkeit des Codes, indem sie sich auf die Logik und das Verhalten der Anwendung konzentriert, anstatt auf die Implementierungsdetails.
• Hervorragende Dokumentation und Community: Die offizielle Dokumentation von Vue.js ist umfassend und gut organisiert, was den Einstieg in das Framework wesentlich erleichtert. Die Vue.js-Community ist aktiv und wächst stetig, was zu einer Vielzahl von Ressourcen, Plugins und Erweiterungen führt, die Entwicklern zur Verfügung stehen.

Warum Vue.js für Webentwickler von Vorteil ist

• Einfache Einarbeitung: Im Vergleich zu anderen Frameworks wie Angular oder React, ist die Lernkurve relativ flach. Dies ermöglicht neuen Entwicklern einen schnellen Einstieg, während erfahrene Entwickler leicht von anderen Frameworks umsteigen können.
• Flexibilität und Skalierbarkeit: Aufgrund der modularen Architektur und progressiven Anpassung eignet sich Vue.js sowohl für kleine als auch für große Projekte. Entwickler können es sowohl für einfache Widgets als auch für komplexe Anwendungen verwenden. Man kann es problemlos in bestehende Projekte integrieren oder als Grundlage für neue Projekte verwenden.
• Verbesserte Produktivität: Durch die Verwendung von Single-File-Komponenten und reaktiven Datenbindungen ermöglicht Vue.js Entwicklern, schneller und effizienter zu arbeiten. Weniger Zeit wird für die Aktualisierung des UI-Codes und die Synchronisierung von Daten aufgewendet, was zu einer höheren Produktivität führt.
• Vast Ecosystem: Das Vue.js-Ökosystem umfasst eine breite Palette von Tools, Bibliotheken und Erweiterungen, die die Entwicklung von Anwendungen beschleunigen und vereinfachen. Beispiele hierfür sind das Vue CLI (Command Line Interface), Vuex für State Management und das Vue Router-Modul für die Navigation.
• Aktive Entwicklung und Wartung: Die Weiterentwicklung und Wartung erfolgt stetig. Folglich kann man immer mit zeitgemäßen neuen Funktionen und Verbesserungen rechnen. Dies stellt sicher, dass das Framework auf dem neuesten Stand der Webentwicklungstechniken bleibt und gleichzeitig sicher und stabil ist.

Fazit

Vue.js hat sich als vielseitiges und leistungsstarkes JavaScript–Framework etabliert, das Entwicklern ermöglicht, auf einfache Weise schnelle und skalierbare Webanwendungen zu erstellen. Mit seinen progressiven Anpassungsmöglichkeiten, reaktiven Datenbindungen und einem wachsenden Ökosystem ist es ein ausgezeichnetes Werkzeug für Webentwickler, unabhängig von ihrem Erfahrungsstand. Die einfache Einarbeitung und Flexibilität von Vue.js machen es zu einer attraktiven Wahl für Entwickler, die nach einer modernen Lösung für die Webentwicklung suchen.

Der Beitrag Vue.js – Das progressive JavaScript Framework erschien zuerst auf CEOsBay.

Was ist Jasmine?

Jasmine ist ein beliebtes Open-Source-Framework für Behavior-Driven Development (BDD) Tests in JavaScript. Man verwendet es hauptsächlich, um das Verhalten von JavaScript-Code durch das Schreiben von Test-Spezifikationen zu überprüfen. Jasmine bietet eine saubere, leicht verständliche Syntax und ermöglicht Entwicklern, ihre Tests unabhängig von ihrer Implementierung auszuführen. Dadurch können sie schnell und effizient sicherstellen, dass ihr Code wie erwartet funktioniert.

Vorteile:

• Einfachheit: Man hat Jasmine entwickelt, um leicht verständlich und zugänglich für Entwickler zu sein. Die Test-Syntax ist klar und einfach, sodass selbst Entwickler, die neu in der Testautomatisierung sind, schnell damit arbeiten können.
• Unabhängigkeit: Jasmine ist unabhängig von anderen JavaScript–Frameworks, Browsern und DOM-Manipulationsbibliotheken, was bedeutet, dass man es praktisch jedem JavaScript-Projekt verwenden kann, unabhängig von der verwendeten Technologie.
• Flexibilität: Entwickler können Jasmine für Unit-Tests, Integrationstests und sogar für End-to-End-Tests verwenden. Dies gibt ihnen die Möglichkeit, das gesamte Verhalten ihrer Anwendung mit einem einzigen Tool abzudecken.

Wie funktioniert Jasmine?

Jasmine basiert auf einer Hierarchie von Suites und Specs. Suites sind Gruppen von verwandten Tests, während Specs einzelne Testfälle sind. Diese Hierarchie ermöglicht es Entwicklern, ihre Tests klar zu strukturieren und den Code leicht zu organisieren.

Es verwendet das „describe“-Konstrukt, um Test-Suites zu definieren. Jede Suite kann mehrere Test-Spezifikationen (Specs) enthalten, die mit dem „it“-Konstrukt definiert werden. Diese Specs enthalten Erwartungen (Expectations) in Bezug auf das zu testende Verhalten des Codes.

Ein einfaches Beispiel für eine Jasmine Test-Suite sieht wie folgt aus:

describe("A suite is just a function", function() {
  let a;

  it("and so is a spec", function() {
    a = true;

    expect(a).toBe(true);
  });
});

oder

describe('Array', () => {
  describe('#indexOf()', () => {
    it('sollte -1 zurückgeben, wenn der Wert nicht im Array vorhanden ist', () => {
      expect([1, 2, 3].indexOf(4)).toBe(-1);
    });
  });
});

Integration in die Softwareentwicklung

Man kann Jasmine problemlos in moderne JavaScript-Projekte und Build-Tools integrieren. Mit Integrationen für Tools wie Grunt, Gulp und Webpack lässt es sich nahtlos in bestehende Entwicklungsprozesse einfügen. Darüber hinaus gibt es auch Jasmine-Plugins für gängige Entwicklungsumgebungen wie Visual Studio Code oder IntelliJ, die das Schreiben und Ausführen von Tests noch einfacher und bequemer gestalten.

Man kann es auch mit anderen Testing-Tools und Libraries kombinieren, um noch umfassendere Testlösungen zu schaffen. Beispielsweise kann man es mit Karma (einem JavaScript-Test-Runner) verwenden, um Tests in verschiedenen Browsern auszuführen, oder mit Protractor für End-to-End-Tests in Angular-Anwendungen.

Best Practices für Jasmine-Tests

Um das Beste aus Jasmine herauszuholen und effektive Tests zu erstellen, sind hier einige bewährte Vorgehensweisen:

• Klare Testbeschreibungen: Man sollte aussagekräftige und präzise Beschreibungen für Suites und Specs verwenden. Dies erleichtert das Verständnis des Testzwecks und die Identifizierung von Fehlern.
• Kleine, fokussierte Tests: Es ist ratsam, Tests zu schreiben, die nur eine Funktion oder ein Verhalten testen. Dies erleichtert das Auffinden und Beheben von Fehlern, da man dadurch genau im Blick behält, welcher Teil des Codes betroffen ist.
• Testabdeckung: Man sollte sicherstellen, dass man eine ausreichende Testabdeckung für den Code hat. Dies bedeutet, dass man alle wichtigen Funktionen und Szenarien in den Tests berücksichtigt.
• Mocking und Spies: Es ist zu empfehlen, Mock-Objekte und Spies zu verwenden, um externe Abhängigkeiten zu isolieren und den Testfokus auf den zu testenden Code zu richten. Jasmine bietet dafür eingebaute Funktionen wie createSpy und spyOn.
• Regelmäßige Testausführung: Man sollte die Tests regelmäßig ausführen, um sicherzustellen, dass Änderungen im Code nicht zu unerwarteten Fehlern führen. Daher ist es ratsam, Jasmine in den Continuous Integration (CI) bzw. Continuous Deployment (CI/CD) Prozess integrieren, um automatisch Tests auszuführen, sobald man Codeänderungen vornimmt.

Fazit

Jasmine ist ein leistungsstarkes und vielseitiges Framework für das Testen von JavaScript-Anwendungen. Mit seiner klaren Syntax, Flexibilität und Integration in moderne Entwicklungsprozesse ist es ein unverzichtbares Werkzeug für jeden JavaScript-Entwickler. Durch die Befolgung der Best Practices und die regelmäßige Ausführung von Tests können Entwickler sicherstellen, dass ihr Code zuverlässig und fehlerfrei funktioniert. Insgesamt trägt Jasmine dazu bei, die Qualität von JavaScript-Anwendungen zu verbessern und die Entwicklungszeit zu reduzieren.

Der Beitrag Jasmine – JavaScript Testautomatisierung erschien zuerst auf CEOsBay.

Was ist ein Test-Harnisch?

Ein Test-Harnisch (engl. test harness) ist ein Framework oder eine Sammlung von Tools, die dazu beitragen, das Testen von Softwareanwendungen zu automatisieren, zu koordinieren und zu überwachen. Im Wesentlichen stellt ein Test-Harnisch eine Umgebung bereit, in der Entwickler und Tester den Code einer Anwendung testen und sicherstellen können, dass er korrekt funktioniert und die Anforderungen erfüllt. Man kann Test-Harnische sowohl für manuelles als auch für automatisiertes Testen verwenden.

Funktionsweise eines Test-Harnisch

Ein Test-Harnisch besteht aus vier Hauptkomponenten:

1. Testtreiber: Der Testtreiber ist für die Ausführung der Tests verantwortlich. Er stellt die Schnittstelle zur Verfügung, über die die Tester die Testfälle ausführen und die Ergebnisse erfassen können.
2. Testdaten: Testdaten sind die Eingaben, die man während des Testprozesses verwendet. Sie bestehen in der Regel aus verschiedenen Datentypen, die man verwendet, um die verschiedenen Funktionen und Komponenten der Anwendung zu testen.
3. Testskripte: Testskripte sind Skripte, die den Testprozess automatisieren. Sie enthalten Anweisungen, wie die Tests ausgeführt und die Analyse der Ergebnisse stattfinden soll.
4. Testergebnisse: Testergebnisse sind die gesammelten Informationen, die aus dem Testprozess resultieren. Sie enthalten Daten über die Leistung der Anwendung, Fehler, die während des Testprozesses aufgetreten sind, und Informationen über die Korrektheit der Funktionen.

Vorteile von Test-Harnischen

• Automatisierung: Test-Harnische automatisieren den Testprozess und reduzieren so den Zeitaufwand und die Mühe, die mit manuellem Testen verbunden sind. Dies ermöglicht es Entwicklern und Testern, sich auf die Analyse der Testergebnisse und die Verbesserung der Softwarequalität zu konzentrieren.
• Wiederverwendbarkeit: Test-Harnische ermöglichen es, Testfälle und Testdaten wiederverwendbar zu gestalten, sodass man sie in verschiedenen Projekten und Anwendungen einsetzen kann.
• Vereinfachung: Test-Harnische vereinfachen den Testprozess, indem sie alle Testaktivitäten zentralisieren und eine einheitliche Testumgebung bereitstellen.
• Effizienz: Test-Harnische steigern die Effizienz des Testprozesses, indem sie die Testabdeckung erhöhen, den Testaufwand reduzieren und eine schnellere Fehlerbehebung ermöglichen.
• Kontinuierliche Integration: Test-Harnische unterstützen kontinuierliche Integration (CI) und kontinuierliche Bereitstellung (CD) in der Softwareentwicklung, indem sie die automatisierte Ausführung von Tests bei jedem Commit oder Build sicherstellen. Siehe hierzu den Beitrag über CI/CD.
• Berichterstattung und Analyse: Test-Harnische bieten umfangreiche Berichtsfunktionen, die es Entwicklern und Testern ermöglichen, den Fortschritt und den Status der Tests zu überwachen, Fehler und Schwachstellen schnell zu identifizieren und fundierte Entscheidungen über die Softwarequalität zu treffen.

Gängige Test-Harnisch-Tools in der Softwarebranche

Es gibt viele Test-Harnisch-Tools und Frameworks auf dem Markt, die verschiedene Programmiersprachen und Anforderungen unterstützen. Einige der bekanntesten sind:

JUnit: JUnit ist ein weit verbreitetes Testframework für Java-Anwendungen, das Test-Harnisch-Funktionalitäten wie Testausführung, Testdatenverwaltung und Ergebnisberichterstattung bietet.

TestNG: TestNG ist ein Testframework für Java-Programme, das auf JUnit basiert und erweiterte Funktionen wie Paralleltestausführung, Testkonfiguration und flexible Testskripterstellung bietet.

NUnit: NUnit ist ein Testframework für .NET-Anwendungen, das Test-Harnisch-Funktionen wie Testausführung, Testdatenverwaltung und Berichterstattung bietet.

Pytest: Pytest ist ein Testframework für Python-Anwendungen, das Test-Harnisch-Funktionalitäten wie Testausführung, Testdatenverwaltung und Ergebnisberichterstattung bietet.

Jasmine: Jasmine ist ein Testframework für JavaScript-Anwendungen, das Test-Harnisch-Funktionalitäten wie Testausführung, Testdatenverwaltung und Ergebnisberichterstattung bietet.

Fazit

Test-Harnische spielen eine entscheidende Rolle in der Softwareentwicklung, indem sie den Testprozess automatisieren, vereinfachen und effizienter gestalten. Durch den Einsatz von Test-Harnischen können Entwickler und Tester sicherstellen, dass ihre Anwendungen die gewünschte Qualität erfüllen und potenzielle Fehler frühzeitig identifiziert und behoben sind, bevor der Release stattfindet. Mit der wachsenden Anzahl von Test-Harnisch-Tools und Frameworks auf dem Markt können Entwickler und Tester leicht eine Lösung finden, die ihren spezifischen Anforderungen und Projektzielen entspricht.

Der Beitrag Test-Harnisch – Qualität und Zuverlässigkeit von Anfang an durch effektive Teststrategien erschien zuerst auf CEOsBay.

Was ist Swagger?

Swagger, auch bekannt als OpenAPI, ist ein Open-Source–Framework zur API-Entwicklung. Es bietet Entwicklern eine standardisierte Methode, um RESTful-APIs zu entwerfen, zu dokumentieren und zu testen. Es hilft Entwicklern dabei, die Kommunikation zwischen verschiedenen Anwendungen zu vereinfachen und fördert die Zusammenarbeit innerhalb und zwischen Teams.

Die wichtigsten Komponenten:

1. Swagger Editor: Ein browserbasiertes Werkzeug zur Erstellung und Bearbeitung von OpenAPI-Spezifikationen.
2. Swagger UI: Eine benutzerfreundliche Oberfläche, die es Entwicklern und Endbenutzern ermöglicht, API-Dokumentationen interaktiv zu visualisieren und zu testen.
3. Swagger Codegen: Ein Generator, der serverseitigen und clientseitigen Code für APIs auf Basis der OpenAPI-Spezifikation erstellt.

Vorteile

1. Klare und präzise API-Dokumentation: Es ermöglicht Entwicklern, leicht verständliche und konsistente API-Dokumentationen zu erstellen. Dadurch wird die Kommunikation zwischen Teammitgliedern und die Integration von APIs in verschiedene Systeme erleichtert.
2. Zeitersparnis: Die automatische Generierung von serverseitigem und clientseitigem Code reduziert die manuelle Arbeit und beschleunigt die Entwicklung von APIs.
3. Fördert die Zusammenarbeit: Es erleichtert die Zusammenarbeit zwischen Frontend- und Backend-Entwicklern, indem es eine gemeinsame Sprache und Struktur bietet.
4. Einfache Aktualisierung und Pflege: Man kann Änderungen an einer API problemlos in die bestehende Dokumentation integrieren, ohne dass man die gesamte Dokumentation manuell aktualisieren muss.
5. Benutzerfreundlichkeit: Die visuelle Darstellung der API-Endpunkte durch Swagger UI erleichtert das Verständnis der API-Funktionalität und ermöglicht das Testen direkt aus der Dokumentation heraus.

Fazit

Swagger, im Programmierkontext, hat sich als unverzichtbares Werkzeug für Entwicklerteams etabliert, um effizient und effektiv RESTful-APIs zu entwickeln und zu verwalten. Mit seinen leistungsstarken Funktionen zur Gestaltung, Dokumentation und Zusammenarbeit trägt Swagger wesentlich zur Steigerung der Produktivität und Qualität von Softwareprojekten bei. Es ist nicht nur ein nützliches Tool, sondern auch ein Beispiel dafür, wie offene Standards und innovative Technologien die IT-Landschaft nachhaltig beeinflussen können.

Der Beitrag Swagger – Mühelose API-Dokumentation und Interaktion für effiziente Entwicklungsprozesse erschien zuerst auf CEOsBay.

Im Grunde genommen handelt es sich dabei um zwei Arten von Tools, die zum einen Anweisungen dem Java-Quellcode hinzufügen und dessen Neukompilierung einfordern und zum anderen Tools, die den Bytecode entweder vor oder während der Ausführung instrumentieren. Das Ziel von JaCoCo ist es, herauszufinden, welche Teile des Codes getestet werden, indem es die Codezeilen registriert, die man bei der Ausführung eines Tests ausführt. TDD bzw. Test Driven Development ist diesbezüglich ebenfalls ein gutes Stichwort.

Features von JaCoCo

• Abdeckungsanalyse von Anweisungen (C0), Verzweigungen (C1), Zeilen, Methoden, Typen und zyklomatischer Komplexität (McCabe-Metrik).
• Basiert auf Java-Bytecode und funktioniert daher auch ohne Quelldateien.
• Einfache Integration durch Java-Agent-basierte On-the-fly-Instrumentierung. Andere Integrationsszenarien wie benutzerdefinierte class loader sind über die API möglich.
• Framework-unabhängig: Reibungslose Integration in Java VM-basierte Anwendungen wie einfache Java-Programme, OSGi-Frameworks, Web-Container oder EJB-Server.
• Kompatibel mit allen freigegebenen Java-Klassendateiversionen.
• Unterstützung für verschiedene JVM-Sprachen.
• Verschiedene Berichtsformate (HTML, XML, CSV).
• Remote-Protokoll und JMX-Steuerung zur Anforderung von Ausführungsdaten-Dumps vom Coverage Agent zu jedem beliebigen Zeitpunkt.
• Ant-Tasks zum Sammeln und Verwalten von Ausführungsdaten und zum Erstellen strukturierter Abdeckungsberichte.
• Maven-Plug-in zum Sammeln von Abdeckungsinformationen und Erstellen von Berichten in Maven-Builds.

JaCoCo bietet die Instructions, Line- und Branchabdeckung. Im Gegensatz zu beispielsweise Atlassian Clover und OpenClover, die eine Instrumentierung des Quellcodes erfordern, kann JaCoCo Java Bytecode mit zwei verschiedenen Ansätzen instrumentieren:

1. JCov on the fly, während der Code mit einem Java-Agenten ausgeführt wird beispielsweise wie Cobertura und JCov vor der Ausführung (offline)
2. Man kann es aber auch so konfigurieren, dass man die gesammelten Daten in einer Datei speichert oder via TCP versendet. Im Gegensatz zu Cobertura und EMMA ist die Unterstützung von so ziemlich allen Java Versionen ab der Java Version 7 gewährleistet.

Tools, die JaCoCo verwenden oder enthalten

Einige davon habe ich bereits in diversen Beiträgen thematisiert. Mit einem Klick auf das jeweilige Tool kommt man auf den jeweiligen Beitrag.

• SonarQube JaCoCo Plugin – Standardmäßig für Code Abdeckungsanalysen innerhalb der Code-Qualitätsmanagement-Plattform
• EclEmma Eclipse (Software) Code Coverage Plugin
• Jenkins JaCoCo Plugin
• Netbeans JaCoCo support
• IntelliJ IDEA (Seit Version 11)
• Gradle JaCoCo Plugin
• Visual Studio Team Services
• TeamCity

Fazit

JaCoCo bietet sich für die Codeabdeckungsanalyse bei der modularen Softwareentwicklung bzw. bei den Unit Tests an. Die Abdeckungsgrade geben an, wie viele Anweisungen, Zweige usw. die Tests durchlaufen. Auf Basis der so gewonnenen Erkenntnisse kann man weitere sinnvolle Testfälle ermitteln oder aber nicht beanspruchten bzw. toten Code entfernen. Es gibt kein allgemeingültiges Mindestmaß an Codeabdeckung. Man definiert die jeweils erforderliche Testabdeckung in Anbetracht des Anwendungsfalls nach einer Risikoeinschätzung sowie der eigenen Entwickler-Fähigkeiten.

Der Beitrag JaCoCo – Messen und Optimieren von Testabdeckung für robuste Java-Anwendungen erschien zuerst auf CEOsBay.