Unit -Tests

Im Computerprogrammierung, Unit -Tests ist ein Softwaretest Methode, mit der einzelne Einheiten von Quellcode- Sets eines oder mehrerer Computerprogramms Module Zusammen mit den zugehörigen Kontrolldaten, Verwendung Verfahrenund Betriebsverfahren - werden getestet, um festzustellen, ob sie zur Verwendung geeignet sind.[1]

Geschichte

Vor der Einheitstests, Erfassungs- und Wiederholungstests Werkzeuge waren die Norm. In 1997, Kent Beck und Erich Gamma entwickelt und freigegeben Jung, ein Unit -Test -Framework, der bei populärer wurde Java Entwickler.[2] Google Umarmte automatisierte Tests um 2005–2006.[3]

Beschreibung

Unit -Tests sind normalerweise automatisierte Tests geschrieben und durchlaufen von Softwareentwickler Um sicherzustellen, dass ein Abschnitt einer Anwendung (bezeichnet als "Einheit") erfüllt deren Entwurf und verhält sich wie beabsichtigt.[4] Im VerfahrensprogrammierungEin Gerät könnte ein ganzes Modul sein, aber es handelt sich häufiger um eine individuelle Funktion oder ein individuelles Verfahren. Im Objekt orientierte ProgrammierungEine Einheit ist häufig eine gesamte Schnittstelle wie eine Klasse oder eine individuelle Methode.[5] Durch das Schreiben von Tests zuerst für die kleinsten prüfbaren Einheiten und dann das zusammengesetzte Verhalten zwischen diesen kann man umfassende Tests für komplexe Anwendungen aufbauen.[4]

Probleme zu isolieren, die auftreten können, jeder Testfall sollte unabhängig getestet werden. Ersatzstoffe wie Methodenstubs, Scheinobjekte,[6] Fälschungen, und Testgurte Kann verwendet werden, um ein Modul isoliert zu testen.

Während der Entwicklung kann ein Softwareentwickler Kriterien oder Ergebnisse in den Test codieren, um die Korrektheit des Geräts zu überprüfen. Während der Testfallausführung, Frameworks Protokoll Tests, die ein Kriterium nicht bestehen, und sie in einer Zusammenfassung melden. Dazu ist der am häufigsten verwendete Ansatz die Test - Funktion - erwartete Wert.

Das Schreiben und Wartung von Unit -Tests kann durch die Verwendung schneller durchgeführt werden Parametrisierte Tests. Diese ermöglichen die Ausführung eines Tests mehrmals mit unterschiedlichen Eingangssätzen, wodurch die Duplikation mit dem Testcode verringert wird. Im Gegensatz zu herkömmlichen Unit -Tests, die normalerweise geschlossene Methoden und Testinvarianten sind, führen parametrisierte Tests alle Parametermenge durch. Parametrisierte Tests werden von unterstützt von Testng, Jung und sein .NET -Gegenstück, Xunit. Geeignete Parameter für die Unit -Tests können manuell oder in einigen Fällen automatisch durch das Testframework generiert werden. In den letzten Jahren wurde Unterstützung für das Schreiben leistungsfähigerer (Einheiten-) Tests hinzugefügt, wobei das Konzept der Theorien genutzt wurde, Testfälle, die dieselben Schritte ausführen, jedoch die zur Laufzeit generierten Testdaten verwenden, im Gegensatz zu regelmäßigen parametrisierten Tests, bei denen dieselben Ausführungsschritte mit Eingabesätzen verwendet werden das sind vordefiniert.[7][8][9]

Vorteile

Ziel der Einheitstests ist es, jeden Teil des Programms zu isolieren und zu zeigen, dass die einzelnen Teile korrekt sind.[1] Ein Unit -Test bietet einen strengen, geschriebenen, geschrieben Vertrag dass das Stück Code befriedigen muss. Infolgedessen bietet es mehrere Vorteile.

Unit -Tests findet zu Beginn der Probleme Probleme Entwicklungszyklus. Dies umfasst beide Fehler in der Implementierung und Mängel des Programmierers oder fehlende Teile der Spezifikation für das Gerät. Der Prozess des Schreibens einer gründlichen Reihe von Tests zwingt den Autor, Eingaben, Ausgänge und Fehlerbedingungen durchzudenken, und definieren somit das gewünschte Verhalten der Einheit. Die Kosten für die Suche nach einem Fehler vor dem Codieren beginnen oder wenn der Code zum ersten Mal geschrieben wird, sind erheblich niedriger als die Kosten für die spätere Erkennung, Identifizierung und Korrektur des Fehlers. Fehler im veröffentlichten Code können auch kostspielige Probleme für die Endbenutzer der Software verursachen.[10][11][12] Der Code kann unmöglich oder schwer zu einem Unit -Test sein, wenn es schlecht geschrieben ist. Daher kann Unit -Tests Entwickler dazu zwingen, Funktionen und Objekte auf bessere Weise zu strukturieren.

Im Testgetriebene Entwicklung (TDD), das häufig in beiden verwendet wird extremes Programmieren und GedrängeEs werden Unit -Tests erstellt, bevor der Code selbst geschrieben wird. Wenn die Tests bestehen, wird dieser Code als vollständig angesehen. Die gleichen Unit -Tests werden häufig gegen diese Funktion durchgeführt, da die größere Codebasis entweder nach geändertem Code oder über einen automatisierten Prozess mit dem Build entwickelt wird. Wenn die Unit -Tests fehlschlagen, gilt dies als ein Fehler entweder im geänderten Code oder in den Tests selbst. Die Einheitentests ermöglichen dann, dass die Position des Fehlers oder des Versagens leicht verfolgt werden. Da die Unit -Tests das Entwicklungsteam des Problems aufmerksam machen, bevor sie den Code an Tester oder Kunden abgeben, werden potenzielle Probleme frühzeitig im Entwicklungsprozess erfasst.

Unit -Tests ermöglicht es dem Programmierer Refaktor Code- oder Upgrade -Systembibliotheken zu einem späteren Zeitpunkt und stellen Sie sicher, dass das Modul noch korrekt funktioniert (z. B. in Regressionstests). Das Verfahren besteht darin, Testfälle für alle zu schreiben Funktionen und Methoden so dass wenn eine Änderung einen Fehler verursacht, schnell identifiziert werden kann. Unit -Tests erkennen Änderungen, die a brechen können Konstruktionsvertrag.

Unit -Tests können die Unsicherheit in den Einheiten selbst verringern und können in a verwendet werden Prost Ansatz des Teststils. Durch das Testen der Teile eines Programms zuerst und dann die Summe seiner Teile testen, Integrationstests wird viel einfacher.

Unit -Tests bietet eine Art lebendige Dokumentation des Systems. Entwickler, die lernen möchten, welche Funktionalität von einer Einheit bereitgestellt wird und wie sie verwendet werden, können die Einheitstests untersuchen, um ein grundlegendes Verständnis der Schnittstelle der Einheit zu erhalten ((API).

Einheit Testfälle verkörpern Eigenschaften, die für den Erfolg der Einheit von entscheidender Bedeutung sind. Diese Eigenschaften können an eine angemessene/unangemessene Verwendung einer Einheit sowie negatives Verhaltensweisen hinweisen, die von der Einheit eingeschlossen werden sollen. Ein Unit -Testfall an und für sich dokumentiert diese kritischen Merkmale, obwohl viele Softwareentwicklungsumgebungen nicht nur auf Code beruhen, um das Produkt in der Entwicklung zu dokumentieren.

Wenn die Software unter Verwendung eines testgetriebenen Ansatzes entwickelt wird, kann die Kombination aus dem Schreiben des Unit-Tests die Schnittstelle sowie die nach dem Test durchgeführten Refactoring-Aktivitäten angeben, und ergreifen möglicherweise den Platz des formellen Designs. Jeder Unit -Test kann als Entwurfselement angesehen werden, das Klassen, Methoden und beobachtbares Verhalten angibt.

Einschränkungen und Nachteile

Das Testen wird nicht jeden Fehler im Programm erfassen, da es nicht jeden Ausführungspfad in jedem als die trivialsten Programme bewerten kann. Dies Problem ist ein Superset der Problem stoppen, welches ist unentscheidbar. Gleiches gilt für Unit -Tests. Darüber hinaus testet Unit -Tests per Definition nur die Funktionalität der Einheiten selbst. Daher werden keine Integrationsfehler oder umfassendere Fehler auf Systemebene (z. B. Funktionen über mehrere Einheiten oder nicht funktionale Testbereiche wie z. Leistung). Unit -Tests sollten in Verbindung mit anderen durchgeführt werden Softwaretest Aktivitäten, da sie nur das Vorhandensein oder Fehlen bestimmter Fehler zeigen können; Sie können keine vollständige Abwesenheit von Fehlern beweisen. Um das korrekte Verhalten für jeden Ausführungspfad und jeden möglichen Eingang zu gewährleisten und das Fehlen von Fehlern sicherzustellen, sind andere Techniken erforderlich, nämlich die Anwendung von Formale Methoden zu beweisen, dass eine Softwarekomponente kein unerwartetes Verhalten hat.

Eine ausführliche Hierarchie von Unit -Tests entspricht nicht der Integrationstests. Die Integration mit peripheren Einheiten sollte in Integrationstests enthalten sein, jedoch nicht in Unit -Tests. Integrationstests hängen normalerweise immer noch stark von Menschen ab manuell testen; Auf hohe oder globale SCOPE-Tests können schwierig zu automatisieren sein, sodass manuelle Tests häufig schneller und billiger erscheint.

Softwaretests sind ein kombinatorisches Problem. Zum Beispiel erfordert jede boolesche Entscheidungsaussage mindestens zwei Tests: eines mit einem Ergebnis von "wahr" und eines mit einem Ergebnis von "Falsch". Infolgedessen benötigen Programmierer für jede geschriebene Codezeile häufig 3 bis 5 Testzeilen.[13] Dies braucht offensichtlich Zeit und seine Investition ist die Mühe möglicherweise nicht wert. Es gibt Probleme, die überhaupt nicht leicht getestet werden können - zum Beispiel diejenigen, die es sind Nichtdeterministisch oder mehrere einbeziehen Themen. Darüber hinaus ist der Code für einen Unit -Test wahrscheinlich ebenso fehlerhaft wie der Code, den er testet. Fred Brooks in Der mythische Mannmonatsmonat Zitate: "Gehen Sie niemals mit zwei Chronometern auf See; nehmen Sie ein oder drei."[14] Bedeutung, wenn zwei Chronometer Widersprechen Sie, woher wissen Sie, welches richtig ist?

Eine weitere Herausforderung im Zusammenhang mit dem Schreiben der Unit -Tests ist die Schwierigkeit, realistische und nützliche Tests einzurichten. Es ist notwendig, relevante Anfangsbedingungen zu erstellen, damit der Teil der getesteten Anwendung wie ein Teil des gesamten Systems verhält. Wenn diese Anfangsbedingungen nicht korrekt festgelegt werden, übt der Test den Code nicht in einem realistischen Kontext aus, was den Wert und die Genauigkeit von Unit -Testergebnissen verringert.[15]

Um die beabsichtigten Vorteile von Unit -Tests zu erhalten, ist während des gesamten Softwareentwicklungsprozesses eine strenge Disziplin erforderlich. Es ist wichtig, sorgfältige Aufzeichnungen nicht nur über die durchgeführten Tests zu führen, sondern auch für alle Änderungen, die am Quellcode dieses oder einer anderen Einheit in der Software vorgenommen wurden. Verwendung von a Versionskontrolle System ist wesentlich. Wenn eine spätere Version des Geräts einen bestimmten Test nicht bestanden hat, den sie zuvor bestanden hatte, kann die Versionskontrollsoftware eine Liste der Quellcodeänderungen (falls vorhanden) angeben, die seit diesem Zeitpunkt auf das Gerät angewendet wurden.

Es ist auch wichtig, einen nachhaltigen Prozess zu implementieren, um sicherzustellen, dass Testfallversagen regelmäßig überprüft und sofort behandelt werden.[16] Wenn ein solcher Prozess nicht in den Workflow des Teams implementiert und verwurzelt ist, wird sich die Anwendung aus der Synchronisierung mit der Unit Test Suite entwickelt, wodurch falsch positive Ergebnisse erhöht und die Wirksamkeit der Testsuite verringert wird.

Eingebettete System -Software für Unit -Tests stellt eine einzigartige Herausforderung dar: Da die Software auf einer anderen Plattform entwickelt wird als die, auf die sie schließlich ausgeführt wird, können Sie ein Testprogramm in der tatsächlichen Bereitstellungsumgebung nicht ohne weiteres ausführen, wie dies bei Desktop -Programmen möglich ist.[17]

Unit -Tests sind in der Regel am einfachsten, wenn eine Methode Eingabeparameter und einige Ausgaben aufweist. Es ist nicht so einfach, Unit -Tests zu erstellen, wenn eine Hauptfunktion der Methode darin besteht, mit etwas externen zur Anwendung zu interagieren. Beispielsweise erfordert eine Methode, die mit einer Datenbank funktioniert, möglicherweise eine Verspottung von Datenbankinteraktionen, die wahrscheinlich nicht so umfassend sein werden wie die realen Datenbankinteraktionen.[18]

Beispiel

Hier ist eine Reihe von Testfällen in Java Dadurch werden eine Reihe von Elementen der Implementierung angegeben. Erstens muss es eine Schnittstelle namens Adder und eine Implementierungsklasse mit einem Null-Argument-Konstruktor namens AdderImpl geben. Es geht weiter behaupten dass die Adder -Schnittstelle eine Methode namens Add mit zwei Ganzzahlparametern haben sollte, die eine weitere Ganzzahl zurückgibt. Es gibt auch das Verhalten dieser Methode für einen kleinen Wertebereich über eine Reihe von Testmethoden an.

statisch importieren org.junit.assert.assertequals; importieren org.junit.test; Öffentlichkeit Klasse Testade {  @Prüfen  Öffentlichkeit Leere testsumpositivenumbersoneandone() {  Addierer Addierer = Neu Adderimpl();  Assertequals(2, Addierer.hinzufügen(1, 1));  }  // Kann es die positiven Zahlen 1 und 2 hinzufügen?  @Prüfen  Öffentlichkeit Leere testsumpositivenumbersoneandtwo() {  Addierer Addierer = Neu Adderimpl();  Assertequals(3, Addierer.hinzufügen(1, 2));  }  // Kann es die positiven Zahlen 2 und 2 hinzufügen?  @Prüfen  Öffentlichkeit Leere testsUpositivenBerstwoandtwo() {  Addierer Addierer = Neu Adderimpl();  Assertequals(4, Addierer.hinzufügen(2, 2));  }  // Ist null neutral?  @Prüfen  Öffentlichkeit Leere Testsumzeroneutral() {  Addierer Addierer = Neu Adderimpl();  Assertequals(0, Addierer.hinzufügen(0, 0));  }  // Kann es die negativen Zahlen -1 und -2 hinzufügen?  @Prüfen  Öffentlichkeit Leere testsumnegativenumbers() {  Addierer Addierer = Neu Adderimpl();  Assertequals(-3, Addierer.hinzufügen(-1, -2));  }  // Kann es positiv und negativ hinzufügen?  @Prüfen  Öffentlichkeit Leere testsumpositiveandnegative() {  Addierer Addierer = Neu Adderimpl();  Assertequals(0, Addierer.hinzufügen(-1, 1));  }  // Wie wäre es mit größeren Zahlen?  @Prüfen  Öffentlichkeit Leere Testsumlargenumbers() {  Addierer Addierer = Neu Adderimpl();  Assertequals(2222, Addierer.hinzufügen(1234, 988));  } } 

In diesem Fall fungieren die Unit -Tests, die zuerst geschrieben wurden, als Entwurfsdokument, das die Form und das Verhalten einer gewünschten Lösung spezifiziert, jedoch nicht als Implementierungsdetails, die für den Programmierer übrig bleiben. Befolgen Sie die Praxis "Tun Sie das einfachste, was möglicherweise funktionieren könnte".

Schnittstelle Addierer {  int hinzufügen(int a, int b); } Klasse Adderimpl Geräte Addierer {  Öffentlichkeit int hinzufügen(int a, int b) {  Rückkehr a + b;  } } 

Als ausführbare Spezifikationen

Die Verwendung von Einheits-Tests als Entwurfsspezifikation hat einen erheblichen Vorteil gegenüber anderen Entwurfsmethoden: Das Designdokument (die Einheitentests selbst) kann selbst verwendet werden, um die Implementierung zu überprüfen. Die Tests werden niemals bestehen, es sei denn, der Entwickler implementiert eine Lösung gemäß dem Design.

Unit -Tests fehlen einen gewissen Zugang zu einer diagrammatischen Spezifikation wie a Uml Diagramm, aber sie können aus dem Unit -Test mit automatisierten Werkzeugen generiert werden. Die meisten modernen Sprachen haben kostenlose Tools (normalerweise als Erweiterungen zur Verfügung Ides). Kostenlose Tools, wie die auf dem basierend auf dem Xunit Framework, ausgelagert an ein anderes System Die grafische Darstellung einer Sicht auf den menschlichen Verbrauch.

Anwendungen

Extremes Programmieren

Unit -Tests ist der Eckpfeiler von extremes Programmieren, was auf einem automatisierten stützt Einheitstest -Framework. Dieser automatisierte Rahmen für Einheiten -Tests kann entweder Dritter sein, z. B., Xunitoder in der Entwicklungsgruppe erstellt.

Extreme Programmierung verwendet die Erstellung von Unit -Tests für Testgetriebene Entwicklung. Der Entwickler schreibt einen Unit -Test, der entweder eine Softwareanforderung oder einen Defekt enthüllt. Dieser Test schlägt fehl, da entweder die Anforderung noch nicht implementiert wird oder weil er absichtlich einen Defekt im vorhandenen Code aufdeckt. Dann schreibt der Entwickler den einfachsten Code, um den Test zusammen mit anderen Tests zu bestehen.

Der meiste Code in einem System wird geprüft, aber nicht unbedingt alle Pfade durch den Code. Extreme Programming schreibt eine "alles testen Sie alles, was möglicherweise brechen kann" Strategie gegenüber der traditionellen Methode "Testen Sie jede Ausführungspfad". Dies führt die Entwickler dazu, weniger Tests als klassische Methoden zu entwickeln, aber dies ist kein Problem, sondern eher eine Wiederholung von Tatsachen, da klassische Methoden selten methodisch genug befolgt wurden, damit alle Ausführungspfade gründlich getestet wurden. Extreme Programmierung erkennt lediglich, dass Tests selten erschöpfend sind (da es oft zu teuer und zeitaufwändig ist, um wirtschaftlich rentabel zu sein) und leitet, wie begrenzte Ressourcen effektiv fokussiert werden können.

Entscheidend ist, dass der Testcode als erstklassiges Projektartefakt betrachtet wird, da er in der gleichen Qualität wie der Implementierungscode beibehalten wird, wobei die gesamte Duplizierung entfernt wird. Die Entwickler veröffentlichen in Verbindung mit dem von ihm getesteten Code den Code -Testcode für den Unit -Test für das Code -Repository. Die gründlichen Tests von Extreme Programing ermöglichen die oben genannten Vorteile, wie z. B. einfachere und selbstbewusstere Codeentwicklung und Refactoring, vereinfachte Codeintegration, genaue Dokumentation und modulare Designs. Diese Unit -Tests werden ebenfalls ständig als Form von durchgeführt Regressionstest.

Unit -Tests sind auch für das Konzept von entscheidend Emergentes Design. Da das entstehende Design stark vom Refactoring abhängt, sind Unit -Tests eine integrale Komponente.[19]

Rahmenbedingungen für Unit -Tests

Unit-Test-Frameworks sind meistens Produkte von Drittanbietern, die nicht als Teil der Compiler Suite verteilt sind. Sie helfen dabei eine Vielzahl von Sprachen.

Es ist im Allgemeinen möglich, Unit -Tests ohne Unterstützung eines bestimmten Frameworks durchzuführen, indem Clientcode geschrieben wird, die die zu testenden Einheiten ausüben und verwendet Behauptungen, Ausnahmebehandlung, oder andere Steuerfluss Mechanismen zum Signalversagen. Unit -Tests ohne Framework sind insofern wertvoll, da es a gibt Zutrittsschranke zur Übernahme von Unit -Tests; Es ist kaum besser als gar nicht zu haben, während ein Rahmen, sobald ein Rahmen vorhanden ist, relativ einfach ist, während ein Rahmen eingerichtet wird.[20] In einigen Frameworks fehlen viele erweiterte Unit-Testfunktionen oder müssen von Hand codiert werden.

Unterstützung auf Sprachniveauentests

Einige Programmiersprachen unterstützen die Unit -Tests direkt. Ihre Grammatik ermöglicht die direkte Erklärung von Unit -Tests, ohne eine Bibliothek zu importieren (ob Dritter oder Standard). Darüber hinaus können die booleschen Bedingungen der Unit-Tests in derselben Syntax wie im Testcode für Nichteinheitstests verwendet werden, z. B. das, was verwendet wird if und while Aussagen.

Sprachen mit integrierter Unterstützung für die Einheitstests umfassen:

Einige Sprachen haben keine integrierte Unterstützung für den Einheits-Test, sondern haben Bibliotheken oder Frameworks für Unit-Tests festgelegt. Diese Sprachen umfassen:

Siehe auch

Verweise

  1. ^ a b Kolawa, Adam; Huizinga, Dorota (2007). Automatisierte Defektprävention: Best Practices im Softwaremanagement. Wiley-ieee Computer Society Press. p. 75. ISBN 978-0-470-04212-0.
  2. ^ Gulati, Shekhar (2017). Java -Unit -Test mit Junit 5: Testgetriebene Entwicklung mit Junit 5. Rahul Sharma. Berkeley, CA: Apress. p. 8. ISBN 978-1-4842-3015-2. OCLC 1012347252.
  3. ^ Winters, Titus (2020). Software -Engineering bei Google: Lehren aus dem Programmieren im Laufe der Zeit gelernt. Tom Manshreck, Hyrum Wright (1. Aufl.). Sebastopol, CA. ISBN 978-1-4920-8274-3. OCLC 1144086840.
  4. ^ a b Hamill, Paul (2004). Unit-Test-Frameworks: Tools für eine qualitativ hochwertige Softwareentwicklung. O'Reilly Media, Inc. ISBN 9780596552817.
  5. ^ Xie, Tao. "Auf dem Weg zu einem Rahmen für Differential-Unit-Tests objektorientierter Programme" (PDF). Abgerufen 23. Juli 2012.
  6. ^ Fowler, Martin (2. Januar 2007). "Mocks sind keine Stummel". Abgerufen 1. April 2008.
  7. ^ "Erste Schritte mit Xunit.net (Desktop)".
  8. ^ "Theorien". GitHub.
  9. ^ "Parametrisierte Tests". GitHub.
  10. ^ Boehm, Barry W.; Papaccio, Philip N. (Oktober 1988). "Softwarekosten verstehen und kontrollieren" (PDF). IEEE -Transaktionen auf Software -Engineering. 14 (10): 1462–1477. doi:10.1109/32.6191. Abgerufen 13. Mai 2016.
  11. ^ "Früh und oft testen". Microsoft.
  12. ^ "Beweisen Sie, dass es funktioniert: Verwenden des Unit -Test -Frameworks für Softwaretests und Validierung". Nationale Instrumente. 21. August 2017.
  13. ^ Cramblitt, Bob (20. September 2007). "Alberto Savoia singt das Lob von Software -Tests". Abgerufen 29. November 2007.
  14. ^ Brooks, Frederick J. (1995) [1975]. Der mythische Mannmonatsmonat. Addison-Wesley. p.64. ISBN 978-0-201-83595-3.
  15. ^ Kolawa, Adam (1. Juli 2009). "Best Practices der Unit -Test". Abgerufen 23. Juli 2012.
  16. ^ Daveiga, NADA (6. Februar 2008). "Code ohne Angst ändern: Verwenden Sie ein Regressionssicherheitsnetz". Abgerufen 8. Februar 2008.
  17. ^ Kucharski, Marek (23. November 2011). "Unit -Tests für die eingebettete Entwicklung praktisch". Abgerufen 20. Juli 2020.
  18. ^ http://wiki.c2.com/?unittestsanddatabases
  19. ^ "Agile Emergent Design". Agile Sherpa. 3. August 2010. archiviert von das Original am 22. März 2012. Abgerufen 8. Mai 2012.
  20. ^ Bullseye Testing Technology (2006–2008). "Zwischenberichterstattungsziele". Abgerufen 24. März 2009.
  21. ^ "Crystal Spec". Crystal-Lang.org. Abgerufen 18. September 2017.
  22. ^ "Unit -Tests - D Programmiersprache". D Programmiersprache. D Sprachgrund. Abgerufen 5. August 2017.
  23. ^ "Testen - Die Go -Programmiersprache". golang.org. Abgerufen 3. Dezember 2013.
  24. ^ "Unit -Test · Die Julia -Sprache". docs.julialang.org. Abgerufen 15. Juni 2022.
  25. ^ Python -Dokumentation (2016). "Unittest - Unit Testing Framework". Abgerufen 18. April 2016.
  26. ^ Welsh, Noel; Culpepper, Ryan. "Rackunit: Unit -Test". PLT Design Inc. Abgerufen 26. Februar 2019.
  27. ^ Welsh, Noel; Culpepper, Ryan. "Rackunit Unit Testing Paket Teil der Hauptverteilung der Schläger". PLT Design Inc. Abgerufen 26. Februar 2019.
  28. ^ "Minitest (Ruby 2.0)". Ruby-doc.org.
  29. ^ The Rust Project Developers (2011–2014). "Die Rost-Testanleitung (Rost 0,12.0-9-Uhr)". Abgerufen 12. August 2014.
  30. ^ Sierra, Stuart. "API für Clojure.test - Clojure v1.6 (stabil)". Abgerufen 11. Februar 2015.
  31. ^ "Pester Framework". GitHub. Abgerufen 28. Januar 2016.

Weitere Lektüre

  • Federn, Michael C. (2005). Effektiv mit dem Legacy -Code arbeiten. Upper Saddle River, NJ: Prentice Hall Professionelle technische Referenz. ISBN 978-0131177055.

Externe Links