ChriSEdu

G

H

G

H

V

H

H

H

F

H

H

G

G

F

G

G

K

K

Um ein

Nur

J

Jo

J

K

J

J

H

J

F

I

U

U

F

G

U

H

H

U

V

H

G

J

Z

H

H

G

G

F

Z

G

Genau

D

R

G

Was ist ein Remote Repository

C

F

G

B

G

H

N

B

H

B

H

U

Vor

H

Vor

H

F

H

U

X

X

H

F

G

G

H

F

B

U

Fehler die vorkamen, als Test implementieren, sodass der selbe Fehler bei Änderung des Codes nicht nochmal auftritt

Tests können nicht veraltet sein wie Kommentare. (Zumindest sieht man wenn der Test fehlschlägt, dass was verändert wurde

Mit tests kann man den code besser verstehen

Wie werden funktionen aufgerufen?
Was sind Beispielwerte?

Wenn es tests gibt unf man bemerkt, dass ein Teil an nötigen Tests nicht abgedeckt wurde, kann der reviewer schneller sehen, welche Schwachstellen es geben könnte.

Bzw. Weis er wo wahrscheinlich weniger fehler sind

Man muss keine angst haben dass ein recatoring das erwartete verhalten verändetrt, da dies die autoamtisierten Tests sofort anzeigen würden

D

X

F

F

Jetzt

H

1. Verstehen was ist die Spezifikation

2. Programm ausführen (evtl source Code anschauen falls möglich)

3. finde Äquivalenzklassen , weil ein repräsentant die gesamte klasse abdeckt, d.h ein test reicht für jede klasse

4. Grenzen analysieren, da dort häufig fehler sein könnten

5. tests für äquklassen schrieben und für grenzen
6. Automatisier die
Tests. 7. von vorne anfangen

Z

An den rändern zu ander klassen

Misst den Zustand nur indirekt, da nur die abgedeckten Codezeilen berücksichtigt werden

F

Wenn Vorbedingungen gelten sollen Nachbedingungen gelten

Wenn vorbedingungen nicht gelten ist es egal was implementierer macht

J

Man könnte in eine Endlosschleife kommen

Gut um sich zu schützen vor dem aufrufer

Verständlichere Fehlermeldungen

Keine Seiteneffekte

J

H

Man kann Verträge durch einen besseren Vertrag austauschen

Und alle inputs die im alten Vertrag möglich sind, funktionieren immer noch. (Es kann nur sein dass man noch mehr inputs geben kann, die es davor nicht gab)

Bei postcondition anders herum outputs können beschrönkter sein
(Ausser wenn im kommentar steht dass dieser output kommen muss, dann darf der nicht mehr gestrichen werden)

V

G

Man unterscheidet häufig private Invarianten (private), die nur der Implementiererin bekannt sind von öffentlichen Invarianten (public), die sowohl der Implementiererin als auch dem Nutzer bekannt sind. Für letztere sind natürlich beide Parteien verantwortlich und können sich darauf verlassen.

Bei privaten Invarianten sollte die Implementiererin sicherstellen, dass der Nutzer diese nicht aus Versehen beobachten oder verletzen kann.

Zum Beispiel könnte eine private Invariante sein, dass ein Feld in einer Klasse korrekt initialisiert ist. Die Implementiererin kann dies zum Beispiel dadurch erreichen, dass das Feld im Konstruktor korrekt initialisiert wird und nicht von außen erreichbar ist. Alternativ wäre es denkbar im Vertrag der Klasse zu erwähnen, dass zuerst eine Initialisierungsmethode aufgerufen werden muss, bevor andere Methoden aufgerufen werden können. In letzterem Fall verschiebt sich die Verantwortung von Implementierung auf Nutzung, was allerdings häufig Fehleranfälliger ist.

In der Praxis gilt es natürlich auch andere Kriterien zu berücksichtigen wie zum Beispiel die Robustheit gegen Fehlverwendung und Sicherheitsaspekte. Häufig werden die Vorbedingungen deshalb nochmals am Übergang von Nutzung zur Implementierung innerhalb der Software Komponente überprüft, auch wenn dies eigentlich die Aufgabe des Nutzers wäre (siehe auch "defensive programming").

H

J

H

H

H

H

V

J

J

H

V

H

H

V

Gegenbeispiel

Für was ist eine Komponente in SRP
verantwortlich?

Was möchte SRP an eine System verbessern?

Wie solten neue Funktionalität implementiert werden?

Der Druck auf die Schaltfläche führt zwar zur Validierung, eventuell gibt es aber auch andere Stellen im Code, die auf die Validierung angewiesen sein könnten.

wie testen wir die Validierung, wenn sie nur bei einem Klick ausgeführt wird.

Aus diesem grund überprüfung der Datei bei anderen Formularüberprüfungen in der entsprechenden Klasse ansiedeln.

fragil — die Komponente hat mehrere Gründe geändert zu werden. Aspekte die eigentlich nicht von einer Änderungen betroffen wären müssen so eventuell trotzdem berücksichtigt werden.

schwer zu verstehen — die Komponente enthält verschiedene Aspekte, die individuell verstanden werden müssen. Eventuell werden diese Aspekte innerhalb der Komponente vermischt, was das Verständnis zusätzlich erschwert.

schwer wiederzuverwenden — da die Komponente mehrere Verantwortungen trägt, ist es schwieriger, Teile davon in anderen Kontexten zu nutzen, ohne unnötige Abhängigkeiten oder irrelevanten Code mit einzuschließen. Dies führt zu einer geringeren Modularität und Flexibilität in der Softwarearchitektur.

schwierig zu testen — Komponenten mit mehreren Verantwortlichkeiten erfordern komplexere Testfälle, da für jede Funktion innerhalb der Komponente unterschiedliche Bedingungen und Szenarien getestet werden müssen. Dies erhöht den Aufwand für die Testentwicklung und -wartung und kann dazu führen, dass Tests weniger präzise sind, was die Qualitätssicherung beeinträchtigt.

Eine Aufteilung einer Komponente ist indiziert, wenn:

anzunehmen ist, dass sich Verantwortungen stets getrennt verändern
verschiedene Verantwortungen meistens von unterschiedlichen Nutzern verwendet werden (siehe auch ISP)
wenn wir manche Verantwortungen / Aspekte optional machen wollen
Gegen eine Aufteilung spricht, wenn:

anzunehmen ist, dass sich die Verantwortungen meistens gemeinsam ändern
verschiedene Verantwortungen häufig von Nutzern gemeinsam genutzt werden
alle Verantwortungen nicht-optional sind

Insbesondere führt das exzessive Aufteilen von Komponenten zu einem Entwurf mit einer vielzahl kleiner Komponenten, die jeweils wenig Implementierung enthalten. Hier ist an die Modularitätsvorlesung und Ousterhout's hinweis "Modules should be deep" zu erinnern.

Außerdem ist eine Aufteilung in mehrere Dateien mit einem zusätzlichen kognitiven Aufwand verbunden, da Programmiererinnen nun mehrere Dateien navigieren und öffnen müssen, um sich einen Überblick zu verschaffen

Kohäsion (engl. cohesion) beschreibt, wie eng die Funktionalitäten (oder Teilkomponenten) innerhalb einer Komponente (z.B. Methoden in einer Klasse, oder Klassen in einem Paket) miteinander verbunden sind. Eine hohe Kohäsion in einer Komponente bedeutet, dass ihre Funktionalitäten eng miteinander verwandt und auf ein gemeinsames Ziel ausgerichtet sind. Dies zeigt sich zum Beispiel darin, dass diese Teilkomponenten sich vermehrt gegenseitig aufrufen.

Wie förder SRP Kohäsion

Kopplung (engl. coupling) hingegen bezieht sich auf das Ausmaß der Abhängigkeiten zwischen verschiedenen Komponenten. Eine lose Kopplung ist erstrebenswert, da sie bedeutet, dass Änderungen in einer Komponente minimale oder keine Auswirkungen auf andere haben.

Das SRP unterstützt lose Kopplung, indem es verhindert, dass eine Komponente zu viele Verantwortlichkeiten übernimmt, die möglicherweise starke Abhängigkeiten zu anderen Teilen des Systems schaffen würden.

Das befolgen von SRP kann also zu einem Entwurf führen, in dem die Komponenten hochkohäsiv und lose gekoppelt sind. Dies wiederum führt zu einem wartbareren, erweiterbaren und robusteren System, in dem Änderungen effizienter durchgeführt werden können.

Das SRP hängt auch mit der Modularitätsregel "Direct Mapping" zusammen, die verlangt, dass technische Lösungen die Struktur des Problems widerspiegeln. Allerdings lässt sich das SRP auch auf interne Implementierungsdetails anwenden, die nicht direkt von Anforderungen des Endnutzers abhängen.

Offen für Erweiterungen. Es sollte möglich sein auf geänderte Anforderungen zu reagieren und Funktionalität anzupassen oder hinzuzufügen.
Geschlossen für Veränderungen. Es ist ausgeschlossen den ursprünglichen Sourcecode einer Komponente zu verändern.

ode zu verändern kann zu neuen Fehlern in der geänderten Komponente führen, die eventuell vorher nicht existiert haben.
Sourcecode zu verändern kann zu Fehlern bei Nutzern der geänderten Komponente führen.
Sourcecode zu verändern ist unter Umständen nicht möglich, da der Sourcecode nicht verfügbar ist.

Das Problem hierbei ist, dass der Nutzercode der Entwicklerin, die die Komponente verändert, eventuell nicht bekannt ist. Wie soll sie sicherstellen, dass ihre Änderung keine Fehler bei den Nutzern eingeführt hat?1

Beim Programmentwurf sind zukünftige Änderungen der Anforderungen zu berücksichtigen.

es sollte die Erweiterbarkeitsdimension gewählt werden, bei der es am Wahrscheinlichsten ist, dass Änderungen / Erweiterungen auftreten.
es sollte nur über einen Erweiterbarkeitspunkt abstrahiert werden, wenn es mehrere, verschiedene Anwendungsfälle (zum Beispiel 3 oder mehr) gibt.
Abstraktion ist ein mächtiges Werkzeug, um Software erweiterbar zu gestalten. Sie führen aber auch recht schnell zu zusätzlichem kognitiven Aufwand

Informell heißt dies, dass Nutzer nicht von Objekten eines Subtyps "überrascht" werden sollen:

Bislang hat der Nutzer immer nur Objekte vom Typ T erhalten.

Der Nutzer konnte bisher beliebige Beobachtungen über diese Objekte vom Typ T machen, was dazu führt, dass seine Implementierung sich auf diese Beobachtungen verlässt.

Wenn wir nun einen Subtyp S einführen und dem Nutzer stattdessen Objekte vom Typ S übergeben, sollte dieser immer noch "funktionieren". Insbesondere sollten alle zuvor gemachten Beobachtungen auch noch immer zutreffen.

Ein häufig einfacher Ansatz das LSP zu berücksichtigen ist es konkrete Implementierungsdetails hinter einer Schnittstelle zu verbergen (siehe Vorlesung zu Modularität und "information hiding"). Offensichtlich können Methoden, die einem Nutzer nicht Verfügung stehen auch nicht genutzt werden, um Beobachtungen zu machen.

Eine alternativer Ansatz, der häufig dabei behilflich ist, das LSP wiederherzustellen ist es auf veränderlichen Zustand zu verzichten. Im Unterschied zur üblichen
Durch das Fehlen von "setter"-Methoden, kann diese Invariante nicht verletzt werden.

Das Überschreiben von Methoden führt häufig zu einer Verletzung von LSP und sollte, wenn möglich, vermieden werden. Ein Sonderfall ist das leere Überschreiben von vermutlich nicht verwendeten Methoden, welches als "Verweigertes Erbe" (engl. refused bequest) bekannt ist.

Eine Subklasse, die in ihrer Dokumentation angibt, dass bestimmte Methoden nicht mehr oder nur in bestimmter Reihenfolge verwendet werden sollen ist häufig ein Anzeichen fragilen Codes.

Veränderlichen Zustand von Basisklassen zu verändern führt häufig zu verletzten Invarianten sowohl bei Nutzern als auch in der Basisklasse selbst.

Zusätzliche Exceptions zu werfen wird zwangsläufig Nutzer überraschen, da diese nur die Ausnahmen der Basisklasse behandeln.

Um Implementierungen wiederverwendbar zu machen ist es häufig besser sich an "Composition over Inheritance" zu halten und über Werte zu abstrahieren, anstatt Vererbung zu nutzen
Überschreiben von konkreten Methoden sollte möglichst vermieden werden
Vererbung kann gezielt verhindert werden (z.B. durch finale Klassen in Java oder den sealed Modifikator in Scala)

Modularität: Durch das Aufteilen von großen Interfaces in kleinere, spezifischere Interfaces ermöglicht das ISP eine bessere Modulbildung. Jedes Interface repräsentiert eine klar definierte Funktion oder Verantwortlichkeit, was die Lesbarkeit und Verständlichkeit des Codes verbessert. Module können unabhängig voneinander entwickelt, getestet und gewartet werden.

Wartbarkeit: Durch die Reduzierung der Abhängigkeiten zwischen Klassen und Interfaces erleichtert das ISP die Wartung von Software. Wenn eine Änderung an einer Klasse oder einem Interface vorgenommen werden muss, sind nur die betroffenen Module davon betroffen. Dies reduziert das Risiko Fehler einzuführen und erleichtert Debugging und Refactoring.

ist. Es fördert eine saubere Trennung von Verantwortlichkeiten, erhöht interne Kohäsion und reduziert die Kopplung zwischen Komponenten.

Module auf höherer Ebene sollten nicht direkt von Modulen auf niedrigerer Ebene abhängen. Beide sollten von Abstraktionen abhängen.Höhere Schichten enthalten hierbei typischerweise Domänenlogik, während untere Schichten für technische Implementierungsdetails verantwortlich sind.

indem diese verschiedenen inhaltlichen Ebenen entkoppelt werden.

zu schlechter Modularität führt:

Wartbarkeit: Änderungen in der Datenbankimplementierung erfordern eventuell Änderungen in BookingSystem
Wiederverwendbarkeit: Es ist nicht möglich die Datenbankimplementierung auszutauschen, ohne BookingSystem signifikant zu ändern
Testbarkeit: Es ist nicht möglich BookingSystem zu testen, ohne eine Datenbank aufzusetzen und diese mit entsprechenden Daten zu füllen.
Verständlichkeit: Um bookRoom zu verstehen, müssen sowohl technische Details, als auch Domänenaspekte verstanden werden.

Das DIP suggeriert, dass die höhere Ebene nicht direkt auf untere Ebenen zugreifen sollte. Stattdessen, sollte es die Dienste, die notwendig sind, um die höhere Ebene zu implementieren, in einer Schnittstelle beschreiben. Diese Schnittstelle ist dabei konzeptionell Teil des höheren Moduls, nicht der technischen Ebene. Die erforderten Dienste entsprechen den Vorbedingungen im Design-by-Contract.

Auf Datenbanken zuzugreifen ist ein Seiteneffekt. Das in der Vorlesung zu Effekten behandelte Functional Core Imperative Shell Entwurfsmuster würde in unserem Beispiel zu einer recht ähnlichen Lösung gelangen. Zumindest würden wir hierbei über die Datenbank (hier MySQL) und ihre effektbehafteten Methoden executeQuery und executeUpdate abstrahieren.

Vertrauen. Tests stärken das Vertrauen in die Korrektheit der Implementierung (wenn auch nie vollständig).
Entwicklung. Häufig ist es schwierig als Entwickler alle Randfälle zu beachten. Unscheinbare Änderungen führen häufig Fehler in diesen Randfällen ein. Automatisierte Tests können dabei helfen diese Randfälle bereits während der Entwicklung zu entdecken und korrekt zu behandeln.

Wartung. Tests helfen dabei sicherzustellen, dass ein Refactoring wirklich ein solches ist. D.h. dass es nicht das beobachtbare Verhalten verändert.

Robustheit. Entdeckte Fehler können in Form eines (sogenannten Regressions-) Tests festgehalten werden. Dadurch wird sichergestellt, dass dieser Fehler nicht wieder durch Entwicklungsarbeiten eingeführt wird.
Dokumentation. Ohne Tests (und Dokumentation) ist es erforderlich den Sourcecode zu lesen, um zu verstehen wie eine Schnittstelle verwendet werden kann. Tests dokumentieren dies in ausführbarer Form und können dabei helfen fremden Sourcecode zu verstehen.

Reviews. Tests beschleunigen das Begutachten von Code, indem sie dokumentieren an welche Fälle gedacht wurde und was das erwartete Ergebnis ist. Die automatisierte Ausführung erspart es Reviewern diese Fälle manuell auszuprobieren.
Modularität. Automatisierte Tests zwingen uns häufig unser Softwaredesign anzupassen, um dies besser testbar zu machen. Zum Beispiel erfordern sie, dass wir Seiteneffekte isolieren (beispielsweise durch Functional Core / Imperative Shell) und Abhängigkeiten zu anderen Modulen konfigurierbar machen (um diese in Isolation zu testen). führen Tests häufig zu einem verbesserten Softwaredesign.

Die Granularität automatisierter Tests beschreibt den Umfang der Softwarekomponenten, die in einzelnen Testszenarien analysiert werden.

Die Auswahl des Granularitätsgrades ist somit ein Abwägen zwischen detailliertem Feedback auf Komponentenebene und dem ganzheitlichen Feedback, das das Zusammenspiel aller Teile der Anwendung berücksichtigt.

ermöglicht eine feingranulare Teststrategie eine punktuelle und isolierte Überprüfung individueller Softwarekomponenten. Dieser Ansatz liefert direktes Feedback über spezifische Funktionalitäten und trägt zu einer präzisen Fehlereingrenzung bei. Dies hilft uns insbesondere bei der Verbesserung der internen Qualität.

Im Gegensatz dazu bieten Tests mit einer gröberen Granularität umfassendes Feedback über die Interaktionen und das gesamte Verhalten der Anwendung. Im Extrem spiegeln sie die Nutzererfahrung in einer Produktionsumgebung wider und sind entscheidend für das Verständnis des realen Einsatzes der Software und damit für die Verbesserung der externen Qualität

Im Fokus dieses Abschnitts stehen sogenannte Unit Tests. Wie der englische Begriff "Unit" bereits verrät, testet ein Unit Test eine bestimmte Code Einheit in Isolation. Die Granularität der Einheit kann variieren: von einzelnen Funktionen, über Klassen, Modulen, bis hin zu einem ganzen Paket.

Eine Test Suite besteht in der Regel aus mehreren Testklassen. Jede dieser Testklassen gruppiert verschiedene Unit Tests thematisch. Diese Aufteilung erleichtert das Auffinden der Tests, das Teilen und Wiederverwenden von Testinfrastruktur, sowie das selektive Ausführen aller Tests in einer Testklasse. Die

Eine Testklasse wiederum besteht in der Regel aus mehreren Testmethoden. Jede dieser Methoden folgt inhaltlich einer ähnlichen Struktur.

Setup. In einem ersten Schritt wird die Testumgebung in einem bekannten Zustand hergestellt. Beim Testen von einfachen Funktionen (insbesondere solche ohne Seiteneffekte) kann dieser Schritt häufig entfallen. Manchmal ist es jedoch erforderlich verschiedene Objekte in den richtigen Zustand zu versetzen, bevor ein Test durchgeführt werden kann.
Interact. Im nächsten Schritt interagiert der Test mit dem SUT. Dies kann z.B. durch Methodenaufrufe / Funktionsaufrufe geschehen.

Assert. Nachdem die Interaktion stattgefunden hat, wird überprüft, ob die Rückgabe dem erwarteten Wert entspricht.
Teardown. Im letzten Schritt wird die Testumgebung abgebaut. Dies ist insbesondere in Sprachen mit manueller Speicherverwaltung notwendig, oder wenn andere Resourcen wie Dateien / Datenbankverbindungen zum Testen verwendet wurden.

Um die Funktion zu testen verwenden wir das Testframework Scala munit, welches wir als Abhängigkeit in unserer build.sbt Datei hinzufügen.

Flaky Tests schlagen scheinbar zufällig fehl und sind schwierig zu reproduzieren. Dies ist häufig der Fall, wenn Tests parallel ausgeführt werden oder Seiteneffekte haben (und zum Beispiel Dateien lesen oder schreiben, die auch von anderen Tests gelesen oder geschrieben werden). Wenn Tests immer wieder fehlschlagen, setzt eventuell eine Fehlerblindheit ein und Entwickler reagieren nicht mehr auf fehlschlagende Tests.

Not Quite Automated Tests erfordern manuelle Intervention bei jeder Ausführung. Zum Beispiel müssen eventuell noch Vorbedingungen manuell hergestellt werden, oder das Ergebnis muss noch manuell abgeglichen werden. Dies beschränkt die Produktivität und kann nicht automatisiert auf einem CI Server durchgeführt werden.

Fragile Tests müssen mitgeändert werden, wenn die Implementierung des SUTs verändert wird. Ein Beispiel sind Tests, die internen Zustand eines SUTs überprüfen, oder private Methoden verwenden. Tests die von Implementierungsdetails abhängen erschweren Refactorings und führen eventuell dazu, dass Entwickler Tests kategorisch ablehnen.

Slow Tests benötigen eine lange Zeit, um durchzulaufen. Dies führt eventuell dazu, dass Tests nicht oft ausgeführt werden und verlangsamt die Zeit bis Entwickler Feedback erhalten. Dies ist insbesondere während der Entwicklung entscheidend, da Tests wertvolle Rückmeldung liefern können.

testen keine interessanten Eigenschaften. Hierzu zählen doppelte Tests, sowie Tests, die unabhängig von der Implementierung des SUT immer erfolgreich sind. Um den letzten Fall auszuschließen, sollte man Tests einmal laufen lassen, bevor das SUT implementiert wird oder ein Fehler behoben wird, um zu überprüfen, dass der Test auch tatsächlich einen Fehler entdeckt.

Der Begriff der Test Fixture kommt aus dem Bereich der Hardwaretests. Um Hardware sinnvoll in Isolation testen zu können ist es häufig notwendig spezielle Vorrichtungen zu konstruieren, die es erlauben das System-under-Test, d.h. die zu testende Einheit, einzuspannen

Nachdem die Funktionalität einzelner Einheiten mit Hilfe von Unit Tests überprüft wurde, wird deren Zusammenspiel in sogenannten Integration Tests überprüft. Der Fokus von Integration Tests liegt somit nicht auf einem einzelnen Modul, sondern darauf wie verschiedene Module miteinander interagieren, um das gewünschte Verhalten zu zeigen.

Der Testablauf des Setup, Interact, Assert, Teardown findet auch Anwendung beim Integration Testing. Jedoch findet jeder dieser Schritte auf der Ebene mehrerer Module statt.

Dadurch, dass Unit Tests vor Integration Tests laufen, sollten die meisten Fehler innerhalb einzelner Komponenten durch diese gefunden werden. Das Ziel von Integration Tests ist somit Fehler zu entdecken, die erst im Zusammenspiel auftreten. Diese Fehler könnten zum Beispiel auftreten, wenn sich Schnittstellen einzelner Komponenten ändern und diese Änderungen nicht überall beachtet wurden.

End-to-End Tests betrachten die Software aus der Perspektive der Nutzer und überprüfen somit die Funktionsweise einer gesamten Anwendung. Aus diesem Grund bieten End-to-End Tests einen guten Einblick in die externe Qualität der Software. Wie bereits öfters besprochen, unterscheidet sich natürlich die Art der Nutzer von Software zu Software.

Batch Anwendungen, d.h. Anwendungen, die nur einmal gestartet werden und dann Berechnungen durchführen. End-to-End Tests simulieren hier häufig genau diese Nutzung programmatisch. Sie führen die Anwendung mit bekannten Eingaben aus und beobachten dann deren Ausgaben.

d.h. Anwendungen, die während der Programmlaufzeit auf Nutzereingaben reagieren. Das Testen von interaktiven Anwendungen gestaltet sich häufig etwas schwieriger. Es erfordert, dass die Testumgebung erkennen kann in welchem Zustand sich die Anwendung befindet und dass sie mit dieser interagieren kann. Eine Form von solchen Tests sind GUI Tests für grafische Anwendungen. Hier wird häufig das Klicken auf Schaltflächen und das Eingeben von Texten automatisiert.

d.h. programmatische Schnittstellen, die über ein bestimmtes Protokoll angesprochen werden. Ein Beispiel hierfür wäre eine REST API eines Wetterdienstes. Um diese zu testen würden wir Anfragen per HTTP an den Dienst stellen und beispielsweise nach dem Wetter in Tübingen fragen.

Art von Tests, die häufig bei End-to-End Tests verwendet wird, sind sogenannte Golden Tests. Hierbei werden die Ausgaben einer Anwendung (z.B. Text bei Batch Anwendungen, Screenshots bei GUI Anwendungen) nach einer erfolgreichen Durchführung gespeichert. Der Golden Test führt die Anwendung dann wieder aus und vergleicht, ob es signifikante Abweichungen zwischen erwarteten Ausgabe und der erhaltenen Ausgabe gibt. Diese Tests sind besonders einfach zu erstellen, da häufig nur Eingabe und Ausgabe als Datei angelegt werden muss. Allerdings können Golden Tests (und End-to-End Tests im Allgemeinen) sehr fragil sein und zu "false negatives" (also fehlgeschlagenen Tests, denen aber kein Fehler zugrunde liegt) führen.

Bei der Formulierung von Black-Box Tests wird in der Regel in den folgenden Schritten vorgegangen:

Spezifikation verstehen
Äquivalenzklassen / Partitionen identifizieren
Randfälle analysieren
Testfälle formulieren

White-Box Tests sollen uns dabei helfen den Zustandsraum einer Softwarekomponenten abzudecken

Konzeptionell können wir uns die Auswertung einer Funktion als Automaten vorstellen. Der Zustand der Funktion setzt sich hierbei z.B. aus der Belegung der lokalen Variablen und der aktuellen Ausführungsposition zusammen. Einen Berechnungsschritt durchzuführen bedeutet einen Übergang in dem Automaten zu machen.

G

Beide Parteien haben unterschiedliche Anforderungen an die Komponente. Die Implementiererin würde zum Beispiel gerne Details in der Implementierung ändern können, um zum Beispiel neue Funktionalitäten umzusetzen oder Fehler zu beheben. Der Nutzer auf der anderen Seite möchte meistens genau das Gegenteil: es sollte sich wenig ändern, so dass der eigene Programmcode auch ohne Änderungen weiterhin gleichbleibend funktioniert.

Eigenschaften, die von der Benutzung des Moduls (vom Funktionsaufruf) nicht betroffen sind

Eigenschaften, die während der Nutzung unverändert weiterhin gelten müssen

It should be possible to add new features to a module, without affecting other modules.

keeping the dependencies low

avoiding cohesion of modules

Modular Maintainability== ::

Maintenance - fixing bugs, improving performance, (...) should not affect other modules.

Beispiele: Software libraries
Unix shell commands
Software as a service

within the module anymore

with (A) we require all the submodules to build the modul in the middle

with (B) we require all modules to be present at the same time, deleting the possibility to have them used in another software system, without the other submodules

with (C) we require all of them as well, because each neighbour depends on its neighbours

Whenever two modules A and B communicate, this must be obvious from the interface of A or B, or both. ==Signaling the dependency for communication within two modules in each of them.==

B

H

H

J

G

J

H

H

H

H

R

H

Larges classes

V

You aint gonna need it

G

V

J

F

C

H

H

H

H

B

J

Hoe to name things

G

G

G

G

C

F

C

G

C

C

C

G

G

G

G

H

G

G

G

G

G

G

G

G

G

G

G

G

G

G

G

Subtyping und Vererbung

T

F

F

F

F

D

H

F

Ein Fehler soll nixht aus nem Modul raus geworden werden, der den Nutzer gar nichts angeht

File not found exceptionsoll nicht geworfen werden

Wenn der Nutzer nicht mal weiß das dateien geöffnet wurden

Softwarelösung sollte relativ nah ander Domäne sein

Damit Übersetzung gut funktioniert und man einfacher Kundenwünsche umsetzen kann

Abhängigkeiten sollten explizit sein
Nicht seiteneffekte verwenden um sachen zusammenzusetzen

Sondern parameter verwenden dafür

Über Sachen abstrahieren

Man versteckt die Details die sich am wahrscheinlichsten ändern

Hinter interface

F

F

T

G

G

Explizit die Verschuldung nachvollziehen über tickets

Oder

Kosten die entstehen wenn man schulden anhäuft im Entwicklungsprozess internalisieren

( wenn man keine schulfen anhäuft bzw schulden beseitigt können neues feautures insgesamt billiger sein)

Nein da man nur interne Struktur verändern darf ohne äußeres verhalten zu ändern

Durch viele tests kann man direkt sehen ob ein Refactoring das Verhalten geändert hat

Wenn das ne öffentlich verfügbare Funktion ist dann ja

Deshalb sollten swap und sesrchsmallest from privat sein

Weil kleine funktionen eher auch in andern Kontexten verwendet werden können

Hilfsfunktionen für die Verständlichkeit einbauen

Dadurch dass man komplette teilausdrücke oder statements extrahiert, kann es sein dass mehrere variablen geschrieben werden

Also wird es immer unangenehmer je mehr veränderlicher zudtand geschrieben wird

Ausserdem kann man schwer aus lokalen kontrollfluss (dchleifen raus

Zustandsraum kann sehr hoch werden es wird schwer das zu verstehen debuggen und zu warten

Man kann den veränderlichen zustand immer übergeben und zurückgeben und dadurch Zustandmod simulieren

Dadurch ist immerhinklar durch die funktionssignatur das zustand reinkommt und rausgeht

Ausdruck

C

C

Man sollte von aussen wenig zugriff haben um Komponenten zu verändern

Also keien setter Methoden außerhalb vom Modul

Man muss den Zustand der Variable im kopf bewahren und es kann sehr viele mögliche Zustände geben

Zum Beispiel gibt es Invarianten wie die Variable soll nur einmal geändert werden

Wichtig ist diese invarianten zu dokumentieren

Idealerweise über compiler , linter etc

Man muss das dokumentieren

Type checker kann nicht helfen fehler zu vermeiden

Als aufrufer kann man leicht Fehler machen

Sie können zu spezialfällen führen

Sie können regeln verletzen z.b algebraische regeln bei zahlen

Mn könnte einen Summentyp verwenden (optional values)

Man könnte eine zusätzliche flag mitgeben (-1, false)

Man könmze auch die Methode aufteilen und bei einer einen sentinel übergeben und bei einer nen normalen wert (dann ist das klar in der signatur)

Man muss immer überprüfen ob irgendwas null ist

Nein man muds schauen ob es None oder sum ist

Es sollte genau so viele Typ inhabitants geben wie es Domänenmitgliefer gibt

Eenn man gleich primitive typen benutzt für unterschiedliche aspekte kann es schnell zu Verwirrung und Versmischung kommen

Kann zu boolean blindness führen. Wenn es nur booleans (statt eigene typen) gibt, kommt es eher dazu dass man die Booleans verwechselt

Es könntr sein dass sie die Datenkapselung verletzen

Wenn man zum beispiel nur auf einer Kollektion also liste odrr so was arbeitest und man wendet dann filter an und map z.b

Oder auch wen man ne variable initialisiert

(Dadurch vermeidet man mutable variablen)

Es ist nicht so dass wir in Felder navigieren oder bestimmte bestandteile rausziehen um eine Funktion aufzurufen

Führen das Programm selbst nicht aus

Es ist nicht möglich alle Eigenschaften entscheiden zu können, aber man kann viele Eigenschaften sehr weit entscheiden und auf smells hinweisen

Mn kann nicht hinweisen ob es schlechite qualität ist, aber z.b dass mutable state verwendet wurde

Ja

Bei perfomancetest wird da überprüft ob der Test innerhalb der jeweiligen Ressource geblieben ist (weniger speicher als maximal erlaubt oder zb weniger zeit als maximal erlaubt)

Wenn man in Java z.b java doc verwendet kann man aus den im Code verwendeten Kommentaren automatisch generierte externe Dokumentation bekommen.

Arguments of same Type

H

H

V

B

V

G

H

V

H

H

G

H

V

V

F

H

H

C

Uc

H

V

V

G

C

D

C

V

G

F

G

H

G

J

V

C

B

V

V

J

J

H

B

J

H

H

V

C

H

H

V

V

B

V

B

H

Hk