Transkripte
1. Einführung: Hallo da. Willkommen zum Kurs über effektives Testen von Software
mit D Net in EX Unit. Nun, zu Beginn
möchte ich mich vorstellen. Mein Name ist Cayo Susa. Ich arbeite derzeit als
Softwarearchitekt und bin seit über zehn Jahren in der Softwareentwicklung
tätig Ich hoffe,
dass ich im Rahmen dieses Kurses mein Fachwissen weitergeben kann. Dass Sie mehr über
Softwaretests lernen und lernen können ,
wie Sie Softwaretests
effektiv gestalten können, wenn es um Unit-Tests
geht. Ich werde auch einen Überblick über die Grundlagen
des
Softwaretests geben und versuchen , Ihnen zu erklären,
warum wir testen sollten Und welche Arten
von
Softwaretests gibt es Nun,
zunächst werde ich über die Grundlagen des
Softwaretests sprechen Wir werden die Testpyramide überprüfen und untersuchen
. Wir werden uns mit Theorie
und Komponententests, Integrationstests,
System- und manuellen Tests befassen. Sie werden
verstehen, warum und wann Sie jede dieser
Teststrategien anwenden sollten. Wir werden uns auch eine Fallstudie
ansehen , die
Hochschulstipendien beinhaltet Auf der Grundlage dieser Fallstudie werden
wir
Unit-Testing-Techniken verwenden, werden
wir
Unit-Testing-Techniken verwenden um die Logik zu testen und einige Randfälle zu
validieren Sie wissen, wie wichtig Unit-Tests sind und wie dadurch Risiken bei
Codeänderungen
und der Validierung
vorhandener Geschäftsregeln reduziert werden
können dadurch Risiken bei
Codeänderungen . Wir werden uns mit den
Grundlagen von X Unit befassen und verstehen,
warum dieses Tool verwendet Dort werden wir Code
implementieren, in dem Sie
Unit-Tests implementieren und die X-Unit-Bibliothek
und die Funktionalitäten
für Unit-Tests
durchgehen die X-Unit-Bibliothek
und die Funktionalitäten
für Unit-Tests
durchgehen und die Funktionalitäten
für Unit-Tests Im Rahmen dieses Kurses werden
wir uns auch mit
anderen Bibliotheken befassen, die
Unit-Tests unterstützen, wie z. B.
Fluent Assertions Wir werden uns mit gängigen Methoden wie der Verwendung des Visual
Studio Test Explorers, Formatierungstests und
Mustern wie dem A-Muster und der Codeabdeckung Anschließend werden wir uns die
Testanforderungen ansehen. Wir werden Komponententests auf der
Grundlage der Softwareanforderungen durchführen. Wir werden den Datenzugriff simulieren, um Unit-Tests zu erleichtern, und unsere Tests
mit Codeabdeckung
überprüfen. Ich lade Sie ein, mit mir an
dieser aufregenden
Lernerfahrung teilzunehmen dieser aufregenden
Lernerfahrung , die Ihnen helfen wird, das nächste Level
zu erreichen. Mein Ziel ist es, dass
Sie
nach diesem Kurs die Grundlagen des
Softwaretests gelernt haben Sie werden
sicher sein,
Unit-Tests mit
gängigen Bibliotheken zu erstellen Unit-Tests mit
gängigen Bibliotheken Sie werden in der Lage sein, Komponententests in
den.NET-Anwendungen effektiv zu
erstellen Abschließend hoffe ich, dass diese
Erfahrung Ihnen technisches Wachstum und Fachwissen im Bereich der
Softwareentwicklung
2. Grundlagen von Softwaretests: Hallo, da. Willkommen zur Lektion über
die Grundlagen
des Softwaretests Lassen Sie uns also darüber sprechen, warum
jemand eine Software testen würde. Ein Softwarefehler kann also ein einzelnes
Projekt oder eine Organisation
gefährden. Je nach Bug
der Software kann
ein Fehler
einen ganzen Vorgang gefährden. Stellen Sie sich vor, Sie implementieren
eine Finanzsoftware und aufgrund eines schwerwiegenden Fehlers gehen
Millionen von Dollar an Transaktionen
verloren. Das kann
Ihre Organisation,
das Projekt, an dem Sie gerade arbeiten,
und auch Sie als Einzelperson gefährden das Projekt, an dem Sie gerade arbeiten, . Softwarequalität.
Als Softwareingenieur liegt
es in Ihrer Verantwortung, die Qualität der von Ihnen produzierten
Software
sicherzustellen. Die Implementierung
hochwertiger Software kann auch zu Wachstum führen. Der dritte Punkt ist Sicherheit. Eine sichere Software
ist unerlässlich, um sich vor
böswilligen Angriffen zu schützen und Datenschutzverletzungen zu verhindern Sie können darüber
nachdenken, Authentifizierung, Autorisierung, Penetationstests und vieles mehr
zu Aus Kostengründen, die Ihrem
Unternehmen Zeit und Geld sparen, Tests eine der
kostengünstigsten Methoden, um
die Qualität und Zuverlässigkeit
Ihrer Software sicherzustellen die Qualität und Zuverlässigkeit
Ihrer Software Schließlich gibt es
noch viele weitere Gründe
, warum Tests helfen können. wird Ihnen in diesem Kurs explizit oder implizit diesem Kurs Lassen Sie uns also etwas tiefer gehen, wenn es um die
Kosten für Softwaretests geht Die Kosten für Fehler, die in der
Produktion auftreten , überwiegen oft
die Kosten für die Prävention Stellen Sie sich vor, eine Aktienhandels-App ist aufgrund
eines Bugs im Code, der mit
geeigneten Komponententests
hätte verhindert werden können, für 2 Stunden
ausgefallen eines Bugs im Code, der mit
geeigneten Komponententests
hätte verhindert werden können, mit
geeigneten Komponententests
hätte verhindert werden Berechnen Sie den Aufwand für
das Debuggen eines Fehlers, das
Vornehmen der Codeänderungen und die anschließende Bereitstellung zuzüglich der
Personalkosten Wenn keine Tests in Betracht gezogen werden, können
Fehler
im Entwicklungsprozess häufig Wenn Entwickler Code in eine
bestimmte Umgebung übertragen, würde die
Qualitätssicherung Fehler finden Es würde an den
Entwickler zurückgehen, der das Problem beheben würde, und dann geht der Code in
die Produktion Sie haben vielleicht gehört, dass
der Test ein langwieriger Prozess ist, aber Übung macht den Meister. Entwickler, bei denen
Tests Teil
ihres Entwicklungszyklus sind, erzielen
in der Regel bessere Ergebnisse. Was sind einige der Ausreden für
Softwaretests? Manchmal wird die Verantwortung auf
das
Qualitätssicherungsteam oder die Qualitätssicherung Qualitätssicherung kann jedoch nicht
jede Änderung am Code testen, da sie normalerweise nicht alle Änderungen im Code kennt
. Meine Software hat nur wenige Fehler. Selbst gut entwickelte
Software erfahrene Techniker arbeiten
, sollte immer noch auf Fehler stoßen, vor allem, wenn das Team
wächst, Größe, Codezeilen und Muster nicht Teil der Anforderungen Softwareanforderungen
sollten das
Testen durch die Eingabe
nichttechnischer Anforderungen schützen Testen durch die Eingabe
nichttechnischer Anforderungen Zu zeitaufwändig
und teuer. Wie bereits
erwähnt, ist die Behebung Produktionsfehlern in der Regel teurer als deren
Vermeidung. Für die Lieferung nicht erforderlich. Softwaretests könnten Teil der Lieferung
sein. Taktiken zur Automatisierung
und Durchführung von Tests mit Codeabdeckungsanalyse könnten Teil einer Bereitstellungspipeline
sein. Schauen wir uns einige Prinzipien an. Kann ich also alles testen? Testen aller Szenarien
in Software ist aufgrund der Vielzahl
möglicher Kombinationen
und Szenarien, die bei der Weiterentwicklung der Software auftreten
können, nicht möglich möglicher Kombinationen
und Szenarien, die bei der Weiterentwicklung der Software auftreten
können, Weiterentwicklung der Software auftreten
können Man muss priorisieren,
was getestet werden soll, und
darüber werden wir sprechen, wenn wir zum Abschnitt über die
Arten von Softwaretests
kommen Wann sollte ich mit dem Testen aufhören? Ziel ist es herauszufinden, welche Arten von Tests für
die Software, die Sie entwickeln,
sinnvoller sind und welchem Teil der Software
sollten Sie dem Testen Priorität einräumen Damit wüssten Sie, wann Sie mit
dem Testen aufhören müssen oder wann überhaupt
testen sollten. Wo sollen getestet werden. Einige Funktionen einer Software sind
wichtiger als andere, z. B. kann ein
Modul für Banktransaktionen höhere Priorität haben als ein Benachrichtigungsbereich
einer Software. Einwandfreies Testen. Es gibt
keine perfekte Testsoftware Wie **** Straw feststellt, können
Tests helfen
, das Vorhandensein von Fehlern festzustellen, nicht deren Fehlen. Es gibt keine fehlerfreie Software.
Endlich die Bedingungen. Für unterschiedliche Software
sind möglicherweise unterschiedliche Tests erforderlich. Eine Web-App erfordert möglicherweise
Strategien, die sich von
einer Desktop-App unterscheiden , die sich
von einer mobilen App unterscheidet.
3. Einheitstests: Hallo da. Willkommen zur
Unit-Testing-Lektion. Unit-Tests sind also klein, wie der Name schon sagt. Wenn das Ziel darin besteht, eine
einzelne Funktion einer Software zu testen, Unit-Tests eine gute Wahl. Unit-Test validiert eine Einheit oder einen Teil eines kleinen
Abschnitts des Codes Unit-Tests sind schnell.
Sie sind klein und schnell. Normalerweise
deckt der Komponententest eine Methode innerhalb einer Klasse ab, wenn Sie
in der objektorientierten Programmierung arbeiten . In den meisten Fällen
testen sie einen Teil der Methode oder das Verhalten
einer einzelnen Methode. Sie hätten also
mehrere
Komponententests , die eine einzelne Methode
auf mehrere Verhaltensweisen testen. Schauen wir uns einige
der Vorteile an. Wie bereits erwähnt, sind
sie schnell. Sie sollten leicht zu kontrollieren sein
, weil sie klein sind. Sie sollten leicht zu schreiben sein
, weil sie klein sind. Und sie dienen auch
als Dokumentation. Schauen wir uns einige
dieser Vorteile an. Manchmal fehlt ihnen die
Realität, weil sie einen so kleinen
Teil des Codes
testen. Da
es sich um Testeinheiten handelt, werden nicht alle Fehler erkannt, da es sich nicht um
Testmethoden handelt, die
miteinander kommunizieren. Und das ist einer der
größten Nachteile. Nun, mit Unit-Tests
können wir die Codeabdeckung messen. Per Definition zeigt eine
Coverage-Metrik, wie viel
Quellcode eine Testsuite
von keinem bis zu 100% ausführt Es ist allgemein bekannt, dass die Codequalität umso
höher ist, je höher
die Cold-Coverage Codequalität umso
höher ist, je höher
die Cold-Coverage Auch wenn Cold Coverage wertvolles Feedback
liefern kann, liefert
sie kein genaues
Feedback zu effektiven Tests. Es ist jedoch
wichtig, die
Code-Coverage zu verstehen und bei Bedarf
Cold Coverage anzuwenden. Schauen wir uns also die Kälteabdeckung an. Die Codeabdeckung besteht im Grunde
aus
Ausführungszeilen oder Code- und Ausführungszeilen geteilt durch die Gesamtzahl der
Codezeilen. Die Kennzahlen zur Code- oder
Testabdeckung zeigen das Verhältnis dieser beiden Elemente. Und das hilft uns zu verstehen wie viel von unserem Code getestet
wurde. Wenn es um die
Abdeckung der
Filialen geht, sind
es im Grunde die Branchen, die durchquert wurden, geteilt durch die Gesamtzahl der Filialabdeckung gibt an, wie viele
Kontrollstrukturen wie Switch- und
NIF-Anweisungen
von mindestens einem
Test in der Suite durchquert werden von mindestens einem Und dann haben wir die
Kernlogik oder Probleme mit Metriken. Es garantiert nicht, dass die Kernlogik
getestet wird. Sie könnten also eine hohe
Codeabdeckung haben und trotzdem nicht
Ihre Kernlogik
der Anwendung testen , weil unsere
Logik mehr damit
zu tun hat , wie Sie
Ihren Test schreiben, als damit , dass
Tests geschrieben werden. Lassen Sie uns, um fortzufahren, die
effektiven Komponententests durchgehen. Sie sollten
kostengünstig und von hohem Wert sein. Sie könnten automatisiert werden und konzentrieren sich auf den
wesentlichen Teil des Codes.
4. Integrationstests: Hallo zusammen. Willkommen zur
Lektion Integrationstests. Wir haben also über
Unit-Tests gesprochen, oder? Sie sind schnell. Sie testen
die Anwendungseinheit. Sie können jedoch nicht sicher
sein, ob Ihr System funktioniert, wenn Sie sich
nur auf Komponententests verlassen. Möglicherweise
muss überprüft werden , wie
verschiedene Teile der Software
miteinander und mit externen Systemen
wie der Datenbank,
dem Nachrichtenbus,
E-Mail-Systemen usw. integriert wie der Datenbank,
dem Nachrichtenbus, werden Integrationstests
helfen zu überprüfen, wie Komponenten bei der Integration
mit externen Systemen funktionieren Wenn Sie über
Integrationstests nachdenken, ist
es wichtig,
ein Gleichgewicht zwischen Einheiten
- und Integrationstests zu wahren. Integrationstests validieren Integrationen mit
externen Systemen Daher ist die
Wartung von
Integrationstests in der Regel teurer als Unit-Tests Bei diesen Tests
wird in der Regel mehr Code ausgeführt als Komponententests, da sie
über externe Abhängigkeiten ausgeführt werden. Dies verbessert den Schutz
vor Regressionen. Mehr als Komponententests. Regressionstests beziehen sich auf eine
Softwaretesttechnik, bei der
nicht funktionale und funktionale
Tests erneut ausgeführt werden, um sicherzustellen, dass eine Softwareanwendung nach Codeänderungen,
Updates,
Überarbeitungen, Verbesserungen, Optimierungen usw. wie
beabsichtigt funktioniert nach Codeänderungen,
Updates,
Überarbeitungen, Verbesserungen, Optimierungen usw. wie
beabsichtigt Updates,
Überarbeitungen, Verbesserungen, Optimierungen . Die Anzahl der Tests zwischen
Integration und Einheit kann von Anwendung
zu Anwendung
drastisch
variieren zu Anwendung
drastisch
variieren Lassen Sie uns also darüber sprechen, wann Integrationstests
angewendet werden sollten. Integrationstests validieren,
wie Software in externe Systeme
und Abhängigkeiten integriert externe Systeme
und Abhängigkeiten Und wenn es um
diese Abhängigkeiten geht, analysieren
wir zwei Typen Die erste ist die Kontrolle von
Abhängigkeiten, bei denen Sie die volle Kontrolle haben, wie zum Beispiel Datenzugriffsmethoden
auf die Datenbank. Bei der zweiten handelt es sich um
unkontrollierte Abhängigkeiten, bei denen Sie nicht
die volle Kontrolle haben, wie bei einer Service-Bus-Bibliothek Was ist, wenn ich nicht auf
Kontrollabhängigkeiten zugreifen kann? Nehmen wir an,
Sie haben aus
Sicherheitsgründen keinen
Zugriff auf eine echte Datenbank für Ihre Kontrollabhängigkeiten. In diesem Fall
sollten Sie es vermeiden,
Integrationstests zu schreiben ,
da diese nur einen geringen Wert bieten. Tests müssen einen Mehrwert bieten. Schließen Sie ab. Der
Integrationstest bestätigt wie Komponenten bei der Integration
mit externen Systemen funktionieren Sie decken die
Darstellungsschicht ab, z. B. Controller, und schützen am besten
vor Regression Auch wenn wir
das auf sehr hohem Niveau behandeln, sind
Integrationstests sehr wichtig Sie sind nicht das
Ziel dieses Kurses, da wir uns
mehr auf Unit-Tests konzentrieren werden. ist jedoch
entscheidend, die verfügbaren
Testtypen zu verstehen , wenn es um die
Planung von Tests geht. Ja.
5. End-to-End-Tests: Hallo da. Willkommen zur
Lektion über beabsichtigte Tests. Into-End-Tests bestehen
aus Tests, die den
Anwendungsworkflow abdecken ,
der normalerweise von einer
Person oder einem Programm durchgeführt wird. Diese Tests helfen bei der Validierung Systemen, bei denen all ihre Komponenten berücksichtigt
werden, z. B. die Datenbank, Servicebus, die Benutzeroberfläche
und andere Integrationen Die Benutzeroberfläche, z. B. die Plattform- oder
Browser-Navigation, und die Backend-Verarbeitung werden
ebenfalls in zehn Tests behandelt Der Entent-Test deckt die Funktionalität der gesamten
Softwareanwendung mit realer Endbenutzersimulation und Replikation von Faktendaten Zu diesem Zeitpunkt ist der Code oder die
Datenbank irrelevant. Die Idee ist, eine
Eingabe für das System bereitzustellen und zu erwarten, dass eine Ausgabe durch denselben Prozess erfolgt
wie der Endbenutzer. Tests bis zum Ende sind realistisch. Daher sollten
Sie bei
dieser Art von Test eine Plattform verwenden ,
auf der das System
läuft. Sie könnten einen Webbrowser verwenden
, um eine Webanwendung zu verifizieren. Sie könnten ein
iPhone verwenden, um
eine IOS-Anwendung zu validieren , oder Windows, um eine
Desktop-Anwendung zu testen. Die Idee ist, dass Sie
alles verwenden , was der
Endbenutzer verwenden wird. Richtig? Wenn Sie also an ein Auto denken, Sie haben einen Motor
und können
Ihren Motor oder Teile
des Motors testen , das wäre Ihr Komponententest. Wenn Sie testen möchten,
wie der Motor
mit anderen Teilen des Autos funktioniert , wäre
das Ihr
Integrationstest. Und dann
würde Ihr zehnfacher Test darin bestehen in das Auto zu
steigen und das Fahrzeug
zu fahren. Schauen wir uns einige
der Vorteile an. Erstens sind Tests realistischer. Methoden werden nicht isoliert
getestet. Stattdessen simulieren Sie
die Tests von der gewünschten Plattform aus
mit Eingaben und Ausgaben. Sie sind zuverlässig
für die Regression. Der Test könnte alle Ebenen
der Anwendung
durchlaufen , angefangen
beim Frontend Und sie geben Ihnen auch
einen Vertrauensschub. Für das Qualitätssicherungsteam können
End-Twin-Tests
als letzten Schritt verwendet werden, können
End-Twin-Tests
als letzten Schritt verwendet werden bevor die Freigabe Produktion
geht, mit Gewissheit, dass die bestehende
Funktionalität nicht beschädigt wurde. Schauen wir uns einige
der Nachteile an. Erstens Leistung. Systemtests sind
im Vergleich zu Komponententests oft langsam. Stellen Sie sich alles vor, was ein
Systemtest oder ein Zehntest tun muss, einschließlich des Startens und Ausführens des gesamten Systems mit
all seinen Komponenten. Der Test
muss auch mit einer
echten Anwendung interagieren , und Aktionen können einige Sekunden
oder sogar Minuten dauern. Zweitens, die Einrichtung der Umgebung. Tests sind auch schwieriger zu schreiben. Einige Komponenten,
wie z. B. die Datenbank, erfordern möglicherweise ein komplexes Setup, bevor sie in einem
Testszenario verwendet werden
können. Denken Sie daran, eine Verbindung zur
Authentifizierung herzustellen und sicherzustellen, dass die Datenbank über alle für den Testfall erforderlichen
Daten verfügt. Nur um den Test zu automatisieren, ist zusätzlicher Code erforderlich. Die Verhaltensvariation. Manchmal kann derselbe
Test je nach Integrationen zu
unterschiedlichen Verhaltensergebnissen führen Stellen Sie sich einen Systemtest vor
, bei dem eine Web-App getestet wird. Nachdem der Tester
auf eine Schaltfläche geklickt hat, eine HTTP-Anfrage an dauert
eine HTTP-Anfrage an
die Web-App eine halbe
Sekunde länger als gewöhnlich. Aufgrund dieser kleinen Abweichung
, die wir oft nicht kontrollieren, kann
der Test fehlschlagen, oder? Der Test wird erneut ausgeführt, und die Web-App benötigt
die übliche Zeit, um zu antworten, und der Test ist erfolgreich. Viele Unsicherheiten
im Systemtest können
zu einem unerwarteten Verhalten führen zu einem unerwarteten Verhalten
6. Die Testpyramide: Hallo, da. Willkommen zur
Lektion über die Testpyramide. Bei der Arbeit mit Tests
ist es wichtig, zunächst
ein klares Verständnis
der verschiedenen Teststufen,
ihrer Vor- und Nachteile zu haben ein klares Verständnis
der . Daher kann Ihr Team investieren, was für
das Ziel der Organisation
oder der Projekte
sinnvoller ist. Die folgende Pyramide enthält
alle Teststufen. Wenn Sie nach dem Testen von Pyramid suchen, sollten
Sie einige Varianten
davon finden. Zuerst haben wir unten
Unit-Tests. Nun, alle wichtigen
Geschäftsregeln können getestet werden. Zweitens haben wir
Integrationstests , bei denen Sie aufgrund
der Integrationen mit
externen Diensten tendenziell komplexer der Integrationen mit
externen Diensten sind
und diese Tests in der Regel für
weniger Szenarien geschrieben werden als Komponententests Schließlich müssen wir die Tests ganz oben
beenden. Es deckt die Funktionalität
der gesamten Softwareanwendung ab
und ist
aufgrund möglicher Änderungen
in der Anwendung tendenziell
komplexer zu schreiben und zu warten . Wie in der
Abbildung zu sehen ist, ist
der untere Teil der Pyramide weniger
realistisch und weniger komplex tendenziell einfacher zu pflegen. Und wenn Sie die Pyramide hinaufsteigen, nehmen Komplexität und
Wartbarkeit zu Unit-Tests sind einfach zu
schreiben. Sie sind schnell. Sie verbinden sich mit dem Fachwissen der
Entwickler und könnten zusammen
mit dem Produktionscode veröffentlicht werden. Bei Integrationstests
liegt der Schwerpunkt auf dem Testen der Integrationen, und das gilt möglicherweise nicht für
einen großen Teil des Codes Möglicherweise gibt es
bestimmte Szenarien , in denen dies
für Integrationstests sinnvoller Schließlich kann die Wartung von Tests
komplexer sein, insbesondere wenn sie automatisiert
sind. Viele Organisationen
wie Kiwi haben speziell für
diesen Zweck
ein spezialisiertes Team wie Kiwi haben speziell für
diesen Zweck Der Schwerpunkt dieses
Kurses wird auf Unit-Tests liegen. Lassen Sie uns also zusammenfassen Das Ziel von
Softwaretests besteht darin, das
Vorhandensein von Fehlern festzustellen Obwohl es
mehrere Arten von Tests gibt, auf den meisten Systemen nicht praktikabel oder möglich, alles ist es
auf den meisten Systemen nicht praktikabel oder möglich, alles zu testen. Schließlich haben wir Teststufen. Es gibt verschiedene
Teststufen , von kleinen Komponententests bis hin zu Tests, die in externe Dienste integriert und jeweils ihren
eigenen einzigartigen Wert bieten. Daher ist es wichtig, dass Sie
als Softwareingenieur, QA-Analyst
oder als jemand, der
an einem Softwareprojekt
beteiligt ist, jeden
dieser Testtypen,
ihr Niveau und den Zeitpunkt ihrer Anwendung verstehen . Ich lade Sie ein, mich auf
dieser Reise zu begleiten, um tiefer zu gehen, neue Fähigkeiten zu
erlernen oder bestehende Fähigkeiten zu
aktualisieren. Ziel ist es, dass
Sie Unit-Tests verstehen, implementieren und
auf Ihre Softwareanwendung anwenden . Wenn Sie sich
als Softwareentwickler oder Analyst für
Qualitätssicherung weiterentwickeln oder etwas über Tests lernen möchten, ist
dieser Weg genau das Richtige für Sie.
7. Fallstudien-Präsentation: Hallo, da. Willkommen zur Lektion über eine
Studienpräsentation. Lassen Sie uns also über die Studie
Cesar Scholarships K sprechen. Cesar College gewährt 50% seiner Bewerber
ein Stipendium
auf der Grundlage ihres Notendurchschnitts an der High School Nach Ablauf der
Bewerbungsfrist werden
die Einreichungen bewertet und die Hälfte der
Studierenden erhält Eine Liste der ausgezeichneten Studierenden wird an den
zuständigen Bereich geschickt. Lassen Sie uns nun darüber nachdenken, wie wir das im Code
implementieren würden. Zunächst würden wir
eine Methode erstellen, die als Berechnung der
ausgezeichneten Bewerber bezeichnet wird. Die Methode würde eine Liste der
Studierenden
erhalten und die
für
das Stipendium in Frage kommenden Studierenden zurückschicken . Die Eingabe ist die Liste
der Namen der Schüler in ihrem jeweiligen
Notendurchschnitt. Das Ergebnis ist die Liste
der ausgezeichneten Schüler. Hier ist ein Codeausschnitt der Methode zur Berechnung
der ausgezeichneten Bewerber Der erste Teil des Codes
verwendet eine.net-Bibliothek namens Link, um
die Bewerber in der Liste nach dem Notendurchschnitt zu
sortieren Im zweiten Teil des
Codes wird die Hälfte der Elemente auf
der Liste beibehalten und die zweite Hälfte
zurückgegeben Da die Liste der Bewerber vom
niedrigsten zum höchsten Wert geordnet
ist, sollte bei
dieser Implementierung die Hälfte
der Studierenden mit
dem höchsten Notendurchschnitt Jetzt führt der Entwickler seine Anwendung aus und
führt einen Testfall durch, und es funktioniert, wie Sie in dieser Abbildung sehen
können Wir haben Kyle und Luena
mit dem höchsten Notendurchschnitt, und das Programm gibt die
richtigen ausgezeichneten Schüler zurück Zu diesem Zeitpunkt sind
Sie als Entwickler mit dem Ergebnis zufrieden
und stellen Ihren
Code in der Produktion bereit Sie arbeiten in einem kleinen Team und es gibt keine Kiwi-Mitglieder, was
in einigen Organisationen sehr typisch ist Ein paar
Stunden später erhalten
Sie jedoch einen Anruf vom Kunden, der besagt, dass die Anwendung
nicht wie erwartet funktioniert In der nächsten Lektion werden
wir untersuchen, was passiert ist und wie Unit-Tests dazu beitragen
können, diese Probleme zu vermeiden.
8. Anwenden von Unit-Tests: Willkommen zur Lektion über angewandte Komponententests
auf einen bestimmten Anwendungsfall. Lassen Sie uns also die Methode zur Berechnung der
vergebenen Bewerberinnen und Bewerber durchgehen. Hier ist der Codeausschnitt
für die Methode. Und lassen Sie uns diese
Logik ganz schnell durchgehen. Im ersten Teil
werden die Schüler grundsätzlich nach
dem Notendurchschnitt geordnet. Im zweiten Teil wird die
Hälfte der Elemente übersprungen und die zweite Hälfte
zurückgegeben Da die Liste geordnet ist, geben
wir die zweite Hälfte der Schüler mit
dem höchsten Notendurchschnitt Hier haben wir also ein Beispiel für einen Komponententest, der für diese Methode
geschrieben wurde Sie sich vorerst keine Gedanken über die Namenskonvention oder darüber,
wie sie erstellt wurde. Mit diesem Test
soll überprüft werden, ob
die Bewerberliste
leer ist , wenn keine
Bewerber eingereicht wurden. Wenn wir ein Acht-Acht-Muster haben , das wir
im nächsten Modul besprechen werden, haben
wir das Arrangement, das Handeln
und die Durchsetzung, wie Sie sehen können. Für diesen Test stellen wir
eine leere Liste zusammen. Wir rufen die Methode auf, berechnen die
ausgezeichneten Bewerber und speichern das in
der Ergebnisvariablen. Zuletzt validieren oder bestätigen wir,
ob das Ergebnis leer ist, was das erwartete Ergebnis ist. Der Test wurde also im
RNR-Code bestanden , ohne dass die eigentliche Anwendung
ausgeführt werden musste Hier haben wir einen zweiten Komponententest. Ziel dieses Tests
ist es, die Hälfte der Bewerber, basierend auf
den eingereichten Bewerbern, zurückzugeben . Wir ordnen die Liste der eingereichten Bewerber und speichern diese in einer tatsächlichen Variablen. Dann erstellen wir eine Liste
der erwarteten Bewerber und speichern diese in der
erwarteten Variablen. Die Methode wird dann aufgerufen und die Bewerber werden
in der Ergebnisvariablen gespeichert. Anschließend überprüfen wir, ob es
sich bei den erwarteten
Bewerbern um dieselben wie die tatsächlichen Bewerber handelt. Der Test ist erfolgreich und wir sind jetzt sicherer, dass der Code wie
erwartet funktioniert. Hier haben wir unseren dritten Komponententest , der einen Bewerber validiert Nachdem Sie den
dritten Komponententest geschrieben
haben, beginnen Sie, Randfälle zu
hinterfragen Wenn sich zwei Kandidaten bewerben, sollten wir nur einen zurückschicken? Wir befragen die Product
Owner und sie sagen, dass wir mindestens zehn
Studenten auszeichnen sollten . Nachdem die Anforderungen
aktualisiert wurden, führen
wir die Tests erneut
für zehn Bewerber durch und
gehen davon aus, dass diese zehn
Bewerber zurückgeschickt werden. Im Grunde arbeiten wir daran,
unseren Test zu scheitern, aber um einer
neuen Geschäftsregel zu folgen. Wir führen den folgenden Test durch, fehlschlägt, weil er die
Hälfte der Bewerber zurückgibt. Wir implementieren jetzt eine
Änderung im Code. Hier überprüfen wir die
Anzahl der Bewerber. Wenn die Gesamtzahl der
Bewerber weniger als 11 beträgt, senden
wir alle Bewerber zurück. Dann führen wir den Komponententest
erneut durch und er ist erfolgreich. Es
fehlt uns jedoch immer noch etwas. Kannst du dir vorstellen
, was fehlt? Was ist, wenn sich 12 Personen bewerben? Der Programmierer gibt sechs zurück. Ich lasse dich
herausfinden, wie du das lösen kannst. Ziel ist es, zu zeigen, wie Unitest Ihnen helfen kann,
die Geschäftslogik
Ihrer Anwendung zu validieren die Geschäftslogik
Ihrer Anwendung und Änderungen an Ihrem
Code mit mehr Sicherheit vorzunehmen Oft sehe ich, dass die
Fehler, die Entwickler machen, sich auf kleine Details beziehen, die Unitest
helfen kann und die sie vermeiden sollten Wenn Sie Komponententests schreiben, hilft
es Ihnen,
systematischer zu denken Wenn wir anfangen,
andere Fälle zu analysieren, können
wir uns Dinge vorstellen wie,
was ist, wenn alle GPAs gleich sind Was ist, wenn der Notendurchschnitt kleiner als eins
ist? Mit der Unit-Test-Strategie können
Sie Änderungen an
Ihrem Code vornehmen, ohne sich Sorgen machen
zu müssen, dass bestehende Funktionen beeinträchtigt werden Sobald Sie Tests
haben, die diese Fälle abdecken, sollte
dies für
alle Entwickler ein
sicherer Booster sein. Sie bieten dem Team mehr Wert und ermöglichen es,
qualitativ hochwertige Projekte zu liefern Der Code für diese Lektion
wird dem Kurs beigefügt.
9. Erste Schritte mit Xunit: Willkommen zur Vorlesung „
Erste Schritte mit XUnits“. Xnut ist also ein kostenloses, Community ausgerichtetes
Open-Source-Unit-Test-Tool für.net Xnut wurde vom ursprünglichen
Erfinder von N Unit Version zwei geschrieben und ist die neueste Technologie für Unit-Tests in C Sharp,
FSAP, visobsic.net X Unit funktioniert mit R
Sharper Cold Rush,
Test driven.net, Test driven.net Es ist Teil der.net Foundation und derzeit unter Apache Two lizenziert Warum sollten Sie also Xnut verwenden? Nun, es wird von
der Community gut genutzt und hat
sich als großartige Bibliothek erwiesen Wie Sie sehen können, gibt es bis
heute mehr als 450 Millionen Downloads auf Nugget Es wurde monatlich,
manchmal mehr als
einmal im
Monat, ständig aktualisiert und verbessert manchmal mehr als
einmal Es ist eine gut gestaltete
Bibliothek, die auf
einer sehr robusten Bibliothek
namens In Unit basiert einer sehr robusten Bibliothek
namens In Unit Die aktuelle Version ist 2.80 Wenn Sie sich dieses Video ansehen, bin
ich mir ziemlich sicher, dass diese
Version bereits aktualisiert wurde oder dass 2.80 nicht
die neueste Version ist Nun, von nun an werden
die meisten Beispiele auf Live Code
implementiert Ich werde die Beispiele in
diesem Modul mit Visual
Studio Professional 2022 implementieren . Wenn Sie jedoch Windows
verwenden, empfehle
ich die kostenlose
Version von Visual Studio. Das ist die Community-Version, und sie hat alle Funktionen
, die wir verwenden werden oder die ich in
Visual Studio 2022 verwenden werde. Sie können Visualstudio
auf visualstudio.microsoft.com herunterladen auf visualstudio.microsoft.com Wenn Sie einen Mac oder Linux verwenden, können Sie Visual Studio Code herunterladen. Okay, lassen Sie uns
mit einer grundlegenden Implementierung beginnen mit einer grundlegenden Implementierung Um zu beginnen,
öffnen
Sie zunächst Visual Studio und erstellen ein neues leeres Projekt Ich habe hier bereits mein leeres
Projekt erstellt. Im Grunde ist es nur eine Vorlage in die wir
neue Projekte einfügen können. Wenn Sie
ein neues leeres Projekt erstellen möchten, klicken Sie
einfach auf Datei > Neues Projekt
und wählen Sie Leere Lösung Das war's im Grunde. Sobald Sie Ihre
Blank-Lösung erstellt haben, oder Sie können die vorhandene Lösung aus
der letzten Lektion verwenden Ich habe den Download-Link
als Teil der Vorlesung hinzugefügt. Sie können also die
vorhandene herunterladen oder eine von Grund auf neu
erstellen, so
wie ich sie hier erstelle. Sie werden also mit der rechten Maustaste auf
die Lösung klicken und ein neues Projekt hinzufügen. Wir werden weitermachen
und Klassenbibliothek auswählen. Wenn du es hier nicht siehst,
kannst du hier danach suchen. Klassenbibliothek. In unserem Fall konzentrieren
wir uns auf das Scharf C, stellen Sie
sicher, dass Sie das Scharf C
hier sehen und klicken Sie auf Weiter. Diese Bibliothek ist
im Grunde eine neue Ebene. Diese Ebene wird
die Geschäftslogik für
die Tests enthalten die Geschäftslogik für , die
wir erstellen werden. Lassen Sie uns weitermachen und
diesen Geschäftspunkt Caesar nennen. Du kannst es nennen,
wie du willst. Ich empfehle das Präfix
Business nur für den Kontext. Als Nächstes werden wir
weitermachen und Det Eight wählen. Die.net-Version spielt hier wirklich keine Rolle. Ob es Standard oder sieben oder
acht oder sogar eine Neun oder Zehn ist, welche Version auch immer Sie sehen, da wir nur
einige grundlegende Funktionen implementieren Also mache ich weiter
und wähle Det 8 und
erstelle und das wird
eine neue Geschäftsebene erstellen, oder eine neue Klassenbibliothek, die wir als
Geschäftsebene repräsentieren. Lassen Sie uns jetzt weitermachen und etwas Logik
implementieren. Also lass uns das umbenennen. Also klicke ich mit der
rechten Maustaste auf
Die erste Klasse umbenennen in Taschenrechner. Und ich werde weitermachen
und eine Methode zum Hinzufügen hinzufügen. Also werde ich einfach die Methode zum Hinzufügen
einfügen. Also das ist eine Anzeige. Sie
gibt A plus B zurück und hat die
Parameter A und B. Wir haben
also unsere
Geschäftsebene und wir haben unsere Rechnerklasse. Sehr einfache Implementierung.
Ich kann hier mit der rechten Maustaste klicken und auf Build , um sicherzugehen, dass wir keine Fehler
haben. Der Build war erfolgreich, und
das war's im Grunde. Lassen Sie uns nun weitermachen und erneut mit der rechten
Maustaste auf die Lösung klicken und auf Neues Projekt hinzufügen klicken. Lassen Sie uns weitermachen und eine
neue Testebene hinzufügen, oder? Lassen Sie uns also weitermachen und
ein X-Unit-Testprojekt auswählen. Also das Gleiche
hier, wenn du da wie einen Test machen
solltest,
ja, hier ist er. Hier gibt es einen Testbereich, also suche ich nach C Sharp. Ich kann sogar
alle Plattformen testen. Und wie Sie sehen können,
gibt es MS-Test-,
N-Unit-, Unit-Test - oder Unit-Test-Projekte
für das Net-Framework. Und im Moment konzentrieren wir
uns auf X Unit. Aber ich möchte nur
zeigen, dass
es hier eine Menge ziemlich
netter Testprojekte gibt. Lassen Sie uns also weitermachen und
unsere Mission hier auf X-Einheiten konzentrieren. Also werde ich die
X-Unit-Vorlage für C Sharp wählen, ich möchte kein Det-Framework verwenden, und ich bin auf Det 8.
Klicken Sie auf Weiter. Ich werde das
Caesar Dot Business nennen , weil wir gerade
die Geschäftsebene testen Lassen Sie uns weitermachen
und diesem Geschäft einen Namen geben. Ich glaube, ich habe versehentlich invertiert, aber das ist in Ordnung, Business
Dot Cesar Dot Test Normalerweise mache ich so etwas wie Cesar Dot Business,
aber das Das Wichtigste dabei
ist, dass wir verstehen, dass dieses Testprojekt
das Business Dot Cesar-Projekt testet das Business Dot Cesar-Projekt Wie Sie sehen können,
lautet das Präfix Business Dot Cesar. Und dann ist das Suffix Test. Das ist also ein
Testprojekt, das die Business
Dot Caesar-Schicht
testet Also halte ich
es gerne sehr explizit. Wenn ich auf Erstellen klicke, sehen wir zwei Projekte in
unserer Lösung. Wir haben den Business Dot Caesar, wo wir unsere Geschäftsregeln haben und den Business
Dot Cesar Dot Test, wo wir unsere Unit-Tests
für die Geschäftsregeln haben Wie Sie sehen können, wird das Ziel-Framework angezeigt,
wenn ich
auf das Projekt klicke Ziel-Framework angezeigt,
wenn ich
auf das Sie werden einige Bibliotheken sehen , die sich in diesem Projekt befinden. Sie können also das
Ziel-Framework sehen, das das Framework
des Projekts
spezifiziert. Sie können die implizite Verwendung der
darin enthaltenen Pakete
deutlich erkennen. Es beinhaltet also die X-Einheiten, was im Grunde das Paket ist , das das
Test-Framework enthält Sie haben den X
Unit-Runner-Punkt Visual Studio und den Microsoft.net
Dot Test Dot SDk Im Grunde sind sie
erforderlich,
damit Sie Ihr Testprojekt
in Visual Studio ausführen Sie haben auch andere Bibliotheken
wie den Covered Collector, dem Sie
Code-Coverage sammeln können , falls Sie dazu neigen. Lassen Sie uns jetzt weitermachen und die Lektion
beenden, richtig? Wir haben unser Projekt erstellt. Wir haben unser Testprojekt erstellt. Wir können mit der rechten Maustaste auf die
Lösung klicken und sie erstellen. Alles wird
erfolgreich gebaut. Und dann werden
wir in der nächsten Lektion einen Komponententest schreiben. Und auch dieses Projekt, Sie können
diese Vorlage aus
dem Download-Bereich
des Kurses herunterladen.
10. Arbeiten mit Test Explorer: Hallo da. Willkommen zur Lektion über
die Arbeit
mit dem Test Explorer. In der letzten Vorlesung haben wir
unseren Test und Testprojekt
erstellt und
wir haben unser Business
Dot Caesar-Projekt erstellt In unserem Business Dot Caesar haben
wir einen Basisrechner, und
wenn Sie dann innerhalb
des Testprojekts ein Testprojekt erstellen, wird automatisch
eine Unit-Test-Klasse erstellt Hier haben wir ein
Faktenattribut, das eine Testmethode
darstellt und diese Testmethode
wird Test One genannt Wir haben eine Testklasse
und eine Testmethode. Jetzt werden wir diese Testmethode
untersuchen. Lassen Sie uns weitermachen und hier auf die Registerkarte Test und dann auf den Test Explorer
klicken. Der Test-Explorer ist der Name
des Fensters, in dem
Sie
Ihre Tests oder Komponententests
in Visual Studio durchsuchen und ausführen können , oder? Sie haben hier
einige Gruppen, wie diese erste Gruppe, Sie Ihre Tests ausführen können, sodass ich alle Tests ausführen kann. Ich kann ausgewählte Tests ausführen, sodass ich tatsächlich den
Test auswählen kann, den ich ausführen möchte. In diesem Fall gibt es nur einen, und ich kann diesen einzelnen Test ausführen. Ich kann den letzten Lauf wiederholen und dann auch meinen fehlgeschlagenen Test
ausführen. Zweiter Tab hier oder
zweiter Abschnitt hier, du kannst
deine Tests irgendwie filtern, oder? Sie haben also die Gesamtzahl der
Tests. Sie können filtern. Ich kann sie alle filtern,
die bestandenen Tests. Wenn ich also hier klicke, weil
es keinen bestandenen Test gibt, weil ich nichts ausgeführt habe, wird einfach nichts angezeigt. Ich kann den fehlgeschlagenen Test filtern und ich kann die
Tests filtern, die nicht ausgeführt wurden. Wenn ich also hier klicke, können
Sie sehen, dass dieser Test noch nicht ausgeführt wurde Es ist
also diese Ebene hier
im Test Explorer. Dann ist der letzte Abschnitt hier ein Ort, an dem Sie Ihren Test konfigurieren können. Sie haben erweiterte
Optionen wie
das Ändern der Prozessorarchitektur und automatische Ausführen Ihrer
Tests nach jedem Test-Build Sie haben die Optionen,
einige Optionen hier. Das ist also nur, um zu konfigurieren, wie sich
das Tool verhalten soll, und Sie können das ausprobieren, wenn
Sie möchten, einige Anpassungen. Lass uns jetzt weitermachen und ein paar Tests
schreiben, richtig? Also werde
ich zuerst diesen Test durchführen, also lassen Sie uns weitermachen und ihn ausführen. Klicken Sie auf Ausführen. Und wie
Sie hier sehen können, lassen Sie mich einfach hier klicken, damit ich alle Tests zeigen
kann. Sie können sehen, dass
es bestanden hat, oder? Ein Test schlägt also fehl, wenn
er explizit fehlschlägt. Obwohl
nichts darauf geschrieben ist, schlägt
er nicht explizit
fehl, also ist er erfolgreich. Lassen Sie uns also weitermachen und einen
echten Test schreiben, oder? Zu diesem Zeitpunkt machen wir uns keine Gedanken über die Formatierung unseres Tests. Genau dafür gibt es eine Lektion. Also werde ich hier einfach einen Code
kopieren, der eine bestandene Prüfung
darstellt
, bei der zwei Zahlen addiert werden, richtig? Also werde ich das als bestandenen Test bezeichnen
. Und ich werde den Assert verwenden. Die Behauptung
prüft im Grunde genommen die Gleichheit. Ich überprüfe, ob
Sie das untersuchen, Sie haben einen erwarteten
und einen tatsächlichen Wert. Ich erwarte also vier, aber mein eigentlicher Wert ist
dieser, weil ich das innerhalb
meiner Taschenrechnerklasse berechne , oder? Damit die
Rechnerklasse hier verwendet werden kann, müssen
wir also auf unser
Business Dot-Testprojekt verweisen. Machen wir also weiter
und klicken mit der rechten Maustaste auf die Abhängigkeit, fügen Sie eine
Projektreferenz und klicken Sie auf
Business Dot Caesar, damit wir unsere
Rechner-Referenz zu diesem Projekt hinzufügen können Da haben Sie's. Sie können jetzt zwei plus zwei
berechnen und der erwartete Wert ist
vier, wenn wir den Test durchführen. Es besteht. Sie können auch
debuggen, was sehr nützlich ist Wenn ich also mit der rechten Maustaste auf
den bestandenen Test klicke, kannst
du auch hier mit der rechten
Maustaste auf die Klasse klicken und dann auf eine davon
und dann einfach auf Debug klicken Sie sehen, es hat meinen Breakpoint erreicht, ich kann mich so oft
darauf einlassen, wie ich will Also hier habe ich A plus B, es kehrt zurück, und dann
bestätigt es sich und es ist erfolgreich Das Debuggen von Unit-Tests ist also eine ziemlich nützliche Funktion Lassen Sie mich weitermachen und hier noch
etwas Code einfügen. Also habe ich
den fehlgeschlagenen Test eingefügt. Also das ist
im Grunde dasselbe, oder? Wir addieren zwei Zahlen, erwarten
aber fünf. Lassen Sie uns also weitermachen und das mit Absicht
scheitern. Lassen Sie mich alle Tests durchführen. Und wie Sie
hier sehen können, ist da ein rotes X. Jetzt schlagen meine Tests fehl,
weil ein Test fehlschlägt, quasi als ob der gesamte
Namensraum fehlschlägt, oder? Also, wenn ich hier
auf den fehlgeschlagenen Test klicke, kann
ich sehen, warum
er fehlgeschlagen ist, oder? Sie können also sehen, dass wir
den Assert verwenden und die
Werte sich unterscheiden. Der erwartete Wert war fünf, aber der tatsächliche Wert war vier. Wie Sie sehen können, versuchen
wir,
zwei plus zwei zu addieren , und es schlägt fehl. Hier können Sie also irgendwie untersuchen,
richtig, oder visualisieren, wie nützlich der
Test-Explorer ist, oder? Sie haben die Zusammenfassung,
warum ein fehlgeschlagener Test fehlgeschlagen ist. Sie haben auch eine Zusammenfassung
der bestandenen Prüfung, z. B. die Dauer usw. Das ist also ein sehr nützliches Tool , das wir
während des gesamten Kurses verwenden werden, und es wird häufig von
Entwicklern verwendet , die
in Visual Studio arbeiten
11. Die Redaktionsfähigkeit Ihrer Tests verbessern: Hallo, willkommen zur Lektion zur Verbesserung
der Lesbarkeit von
Tests Lassen Sie uns also
die Klasse analysieren, die
erstellt wurde, als wir unser
erstes Unit-Test-Projekt erstellt haben Wenn wir uns den
Komponententest einer Klasse ansehen, werden
wir das Faktattribut sehen. Dieses Attribut wird verwendet, um
eine Methode als Testmethode zu kennzeichnen. Es bedeutet, dass eine Methode eine Tatsache
darstellt, die immer wahr sein
sollte Ein mit
dem Faktenattribut markierter Test steht für
einen einzelnen Testfall Wenn die Testmethode
eine Ausnahme auslöst oder bei der Bestätigung
fehlschlägt, wird
der Test als
Fehlschlag oder fehlgeschlagener Test betrachtet Nun, eines der
wichtigsten Dinge beim Testen ist die Benennung Ihrer Der Name Ihrer Tests
, wenn es um
Testmethoden geht , sollte
aus drei Teilen bestehen. Der Name der Methode
, die getestet wird, das Szenario, in dem Test oder unter dem
sie getestet wird, und das erwartete Verhalten, wenn
das Szenario betroffen ist. Und warum ist die Benennung Ihres
Tests so wichtig? Benennungsstandards sind
wichtig, weil sie die
Absicht des Tests
explizit zum Ausdruck bringen. Cest sind mehr als nur
sicherzustellen, dass Ihr Code funktioniert. Sie stellen auch Dokumentation zur Verfügung. Wenn Sie sich nur die
Unit-Test-Suite ansehen, sollten
Sie in der Lage sein,
auf das Verhalten
Ihres Codes zu schließen , ohne sich den Code selbst anzusehen Wenn ein Test fehlschlägt, können
Sie außerdem genau sehen
, welches Szenario die Erwartungen
nicht Wir haben auch ein anderes
Attribut, das Theorie genannt wird. Das Theorieattribut wird verwendet, um einen parametrisierten Test zu definieren Es ermöglicht das Testen
mehrerer Eingaben anhand derselben Testlogik Sie können eine oder
mehrere Datenstrukturen
über Attribute wie
Inline-Daten bereitstellen über Attribute wie , um
den Test mit unterschiedlichen
Eingabewerten zu versorgen . Jeder Satz von
Eingabewerten wird als
separater Testfall behandelt. Wenn einer der Testfälle fehlschlägt, gilt
die gesamte Theorie als gescheitert. Die folgende Abbildung zeigt ein Beispiel für ein verwendetes
Theorieattribut. Das werden wir auch selbst
umsetzen. Ein sehr verbreitetes Muster
ist das AA-Muster, arrangiere, handle und asseriere. Dieses Muster ist in der
gesamten Branche fast zum Standard geworden. Es schlägt vor, dass Sie Ihre Testmethode
in drei Abschnitte
unterteilen sollten : „
Arrangement “, „Action“ und „Assert“. Jeder von ihnen
ist nur für den Teil verantwortlich, nach
dem er benannt ist. Da Lesbarkeit einer
der wichtigsten Aspekte
beim Schreiben von Tests ist , Trennung der einzelnen
Aktionen innerhalb des Tests
deutlich
die Abhängigkeiten hervorgehoben, die zum Aufrufen Ihres Codes
erforderlich sind deutlich
die Abhängigkeiten hervorgehoben , wie Ihr Code aufgerufen wird und was Sie zu behaupten
versuchen Es ist zwar
möglich,
einige Schritte zu kombinieren und
die Größe Ihres Tests zu reduzieren, das Hauptziel besteht jedoch darin, den Test so
lesbar wie möglich zu gestalten Schauen wir uns nun einige
Codebeispiele an. Cool. Also hier haben wir unsere
Unit-Set-Lösung und wir haben unseren
Unit-Test mit
dem fehlgeschlagenen und dem
bestandenen Test, richtig? Also das Erste, was
wir tun werden, ist, unsere Klasse
umzubenennen. Lassen Sie uns also weitermachen und
die Klasse in Taschenrechner umbenennen. Testen. Der Grund, warum wir die Klasse
in Calculator Test umbenannt haben , ist , dass
die Klasse, die
getestet wird , Calculator
heißt,
wie Sie hier sehen können. Wenn wir also eine
Rechner-Testklasse haben, daraus
geschlossen, dass der Rechnertest wird daraus
geschlossen, dass der Rechnertest die Rechnerklasse
innerhalb der Klassenbibliothek der Business
Library testet innerhalb der Klassenbibliothek der Business
Library Machen Sie weiter und benennen Sie unsere Tests um. Um es noch einmal zusammenzufassen:
Der Name des Tests sollte
den Namen der getesteten
Methode,
das Szenario, in
dem getestet wird,
und das erwartete Verhalten enthalten den Namen der getesteten
Methode, das Szenario, in
dem getestet wird, und das erwartete Verhalten Also mache ich weiter und
benenne es um und nenne es add, was der Name
der Methode ist, die unter
Zeile steht , um den nächsten Teil zu trennen Und sagen wir einfach, sollte hinzufügen. Unterstreichen und das
Verhalten des Szenarios. Sagen wir also, wenn Integer. Cool. Wenn wir das lesen, können
wir sehen, dass
wir versuchen, etwas hinzuzufügen,
ich sollte etwas hinzufügen, und wir wissen, dass es sich bei
der Zahl um eine Ganzzahl handelt. Cool. Jetzt können wir uns mit
weiteren Tests befassen, oder? Lassen Sie uns also weitermachen und diese Pastellfarben hier
kopieren. Lassen Sie mich das in eine Theorie umbenennen. Lassen Sie mich
das einfach auf meine Rolle übertragen. Lassen Sie uns weitermachen und einige Inline-Daten
hinzufügen. Jetzt, wo ich die Inline-Daten
habe, werde ich
den fehlgeschlagenen Test löschen. Ich werde
meinen Parameter erstellen. Also in A und B und dem Erwarteten. Lassen Sie uns das in A
ändern, was
eigentlich erwartet wurde, und
wir fügen A und B hinzu Nehmen wir
also an, zwei plus oder
zwei plus zwei ist vier. Vier plus vier ist acht und
acht plus acht ist 16. Lassen Sie mich weitermachen und das auch ein wenig
trennen. Lassen Sie uns
hier angeben, was wir von dem Ergebnis erwarten. Fügen Sie diesen Rechner hinzu und dann ersetzen
wir ihn einfach. Jetzt wäre das Ergebnis meine Tat. Und das wäre meine Behauptung. Also haben wir A hier, oder? Also fehlt uns das Arrangement. Lass uns weitermachen und
den Taschenrechner-Kurs arrangieren. Ich werde
unseren
Einen neuen Rechner speichern unseren Einen neuen Rechner anstatt eine Instanz zu erstellen. Da hast du's. Arrangiere. Wir
arrangieren eine neue Instanz Wir handeln auf der Grundlage der Ergebnisse
und dann behaupten wir, was
erwartet wird und was auf
dem Ergebnis basiert, richtig Also lass mich weitermachen
und diesen Typen kommentieren. Lassen Sie uns weitermachen und uns unseren Test-Explorer
ansehen. Und führe unsere Tests durch. Wie Sie hier sehen können, gibt es drei Tests und alle bestehen
sie, oder? Wir haben eine Methode, die drei Tests
repräsentiert. Also nur um
hier die Anordnung zu überprüfen, sie richtet im Grunde Testobjekte ein und bereitet die Voraussetzungen für Ihren Test vor. Der Act führt die
eigentliche Arbeit des Tests aus, und der Assert
verifiziert das Ergebnis Dadurch wird das, was
getestet wird, klar von den Schritten zur Einrichtung
und Überprüfung
getrennt getestet wird, klar von den Schritten zur Einrichtung
und Überprüfung Okay.
12. Mehr zu Assertions: Hallo, Leute. Willkommen zur
Lektion über Behauptungen. Hier habe ich also eine
Klasse namens Helper erstellt, und diese Klasse
enthält ein G-Modell, das eine neue Instanz des Helper-Modells mit
dem Namen,
dem
Geburtsdatum, dem Bankguthaben
und der Lieblingssammlung der Immobilie zurückgibt Helper-Modells mit
dem Namen,
dem
Geburtsdatum, dem Bankguthaben
und der Lieblingssammlung der Immobilie Geburtsdatum, dem Bankguthaben
und der Lieblingssammlung Wie Sie sehen können,
befindet sich unser Modell in derselben Datei. Habe auch eine Methode
namens Process Helper, die je nach Wert eine Ausnahme zurückgibt. Der Wert ist nein, gibt diesen Wert zurück. Wenn der Wert Eins ist, wird eine nicht
implementierte Ausnahme
zurückgegeben. Wenn der Wert zwei ist, wird eine Ausnahme
zurückgegeben. Diese Klasse
oder diese Hilfsklasse
wird uns also tatsächlich helfen,
die Assertion-Methoden durchzugehen Im Rahmen des Business
Dot Czar Dot Tests haben
wir also eine
Helper-Punkt-Testklasse , die
wir durchgehen werden Lassen Sie uns noch einmal die boolesche Behauptung durchgehen oder mit
ihr beginnen. Die boolesche Behauptung
prüft tatsächlich, ob die Behauptung wahr oder falsch
ist prüft tatsächlich, ob die Sie haben also assert dot true und Sie haben auch assert Was das macht,
das ist die
Instanziierung eines
neuen Hilfsmodells, und dann haben wir den
erwarteten Banksaldo Das Ergebnis ist tatsächlich ein
Modell. Und innerhalb dieses Ergebnisses haben
wir ein Bankguthaben. Wir prüfen also, ob das
Bankguthaben gleich 150 ist, wenn das Bankguthaben 150
ist, dann wird das wahr sein
und es wird passieren. Wenn ich das überprüfe,
kannst du sehen, dass es erfolgreich ist. Wenn ich das
erwartete Bankguthaben
auf 200 ändere und es erneut ausführe, sollte
es fehlschlagen. Und
da hast du's. Es schlägt fehl. Cool. Lassen Sie uns also
weitermachen und mit der Behauptung
der Zeichenkettengleichheit fortfahren Behauptung
der Zeichenkettengleichheit Nun, die
Gleichheitsaussage testet
gewissermaßen die Gleichheit mit dem
erwarteten und dem tatsächlichen Wert Und das ist eine der am häufigsten
verwendeten Methoden zur Bestätigung. Die boolesche Behauptung könnte tatsächlich
durch diese ersetzt werden,
und sie wird oft ignoriert, oder Da die boolesche Assertion quasi mehr Informationen darüber liefert,
warum Hier haben wir also
einen erwarteten Namen, einen erwarteten Vornamen und einen erwarteten Wir erhalten das Ergebnis
aus dem Get-Modell
und prüfen, ob
der Name dieses Modells
dem Vornamen entspricht , wenn er mit
dem erwarteten Vornamen beginnt und ob er mit dem
erwarteten Nachnamen endet. Wenn ich das starte, String-Equality, ist
es hier unten, es ist erfolgreich. Wenn ich mir also mein GET-Modell ansehe, können
Sie sehen, dass der
Name Cayo Susa ist, und wenn ich mir
meinen erwarteten Namen ansehe, ist
es Kyosusa, er beginnt
mit yo und endet mit SSA Gleichheit beginnt also mit einigen unserer Gleichstellungsaussagen und endet Lassen Sie uns also
weitermachen und mit dem nächsten fortfahren. Die nächste ist also eine
numerische Behauptung. Für die numerische Assertion haben
wir also den Bereich assert.in, und es gibt auch den
Assert-Punkt, der nicht im Bereich liegt Also hier prüfen wir, ob das Bankguthaben 10-150
beträgt Also, wenn ich das durchführe,
kannst du sehen, dass es erfolgreich ist, weil
das Bankguthaben 150 ist Wenn wir uns also das ansehen
, das fehlschlägt, prüfen
wir, ob es 10-149 ist Und wenn ich hier klicke, können Sie sehen dass der Wert nicht im zulässigen Bereich liegt Der Bereich liegt zwischen zehn und 149, und der tatsächliche Wert ist 150. Zusammenfassung der Testdetails kann uns also wirklich helfen zu
verstehen, was passiert. Lassen Sie uns also
weitermachen und mit dem nächsten fortfahren. Die nächste ist also die
Referenzaussage. Die Referenz-Assertion behauptet
also, wissen
Sie, dass wir den Assert-Punkt gleich haben Außerdem ist der
Assert-Punkt nicht identisch. Wir haben den Assert-Punkt Nr., Assert-Punkt N-Nr. Ich gehe davon aus, dass das Gleiche in der Null am häufigsten verwendet wird. Das Gleiche behauptet also, dass die erwarteten und tatsächlichen
Objektreferenzen dasselbe Objekt
sind, oder? Hier haben wir also ein Ergebnis, das
das Get-Modell erhält, und wir haben das Helper-Modell, das den Ergebniswert
erhält Diese Objekte
sind also tatsächlich das Ergebnis und das Ergebnis und das Hilfsmodell
sind dasselbe Objekt, oder? Wenn ich das also ausführe, werden Sie
eine Referenz-Assertion in der Vergangenheit sehen. Das kann jedoch
etwas verwirrend werden, oder? Wir haben den Fehler bei der
Referenzzusicherung. Also hier haben wir das Ergebnis. Und dann habe ich hier quasi
ein Hilfsmodell erstellt, das dasselbe Objekt desselben Typs enthält, jedoch mit den gleichen Werten, aber es ist eine neue Instanz. Das Helfermodell enthält also
den gleichen Wertnamen, gleichen Wert, das gleiche
Geburtsdatum, den gleichen Wert, Kontostand und die Sammlung von
Lieblingsspeisen als Ergebnisse. In diesem Sinne ist es also quasi
gleichwertig. Es ist jedoch nicht
dasselbe Objekt da es sich um eine neue Instanz handelt. Wenn ich versuche zu überprüfen
, ob sie
identisch sind, schlägt es tatsächlich fehl. Die Referenzzusicherung schlägt fehl. Und dann haben
wir für unsere nächste Behauptung den Typ Was die Typzusicherung angeht, überprüfen
wir
manchmal vielleicht, ob das Objekt
genau dem Typ entspricht das Objekt
genau dem , den
Sie erwarten Also hier ist das Get-Modell
tatsächlich vom Typ Helper-Modell. Wenn ich das
also in Helper ändere und starte, würden
wir hier einen Fehler erwarten. Da hast du's. Es schlägt fehl, oder? Es ist nicht der genaue Typ. Wenn wir es ändern
oder es auf das
Hilfsmodell zurücksetzen und ausführen, sollte
dies erfolgreich sein. Und da hast du es. Es gilt als bestanden
, weil es vom gleichen Typ ist. Das Ergebnis ist vom Typ Helper-Modell. Cool. Lassen Sie uns also weitermachen und zu den Sammlungen
übergehen. Sammlungen werden also
auch in
vielen Anwendungen häufig verwendet. Das kann also sehr hilfreich sein. So können Sie feststellen, ob eine
Sammlung leer ist. Also unsere Lieblings-Lebensmittelkollektion hier, wo sie
tatsächlich einen Wert hat. Also, wenn ich das auskommentiere und das
ausführe, sollte das fehlschlagen. Die Behauptung ist leer, sie schlägt fehl, weil Reis,
Bohnen und Eier
tatsächlich Teil
der Sammlung Es ist nicht leer. Wenn
ich das ungewöhnlich finde , weil es
irgendwie erzwungen wird, oder? Es zwingt die
Lieblings-Essens-Kollektion zu einer leeren Sammlung. Das wird jetzt tatsächlich
vorübergehen. Da haben wir's. Und dann
haben wir auch das nicht leere. Und wenn wir dieselbe
Lieblingsspeisenkollektion betreiben, wissen
wir, dass Reis drin ist, also wird es nicht scheitern. Da ist die Sammlung, die Behauptungen
enthält. Das beinhaltet also
die Überprüfung
, ob ein erwartetes Objekt in dieser Sammlung
gefunden wird Also hier gibt es ein paar
Möglichkeiten, wie wir das tun können. Ich verwende nur eine Tatsache,
aber Sie könnten
die Theorie verwenden oder es
anders machen. Aber schauen wir es uns einfach
an, wie es ist, oder? Hier überprüfen wir also, ob die Lieblingsspeisensammlung Reis,
Bohnen oder Eier und
in diesem Fall Eier
enthält , oder? Reis, Bohnen und Eier, und sie enthält, wenn
ich das auf Ei ändere, sollte
sie fehlschlagen, weil
sie kein Ei enthält. Weißt du, es enthält Eier. Cool. Und es enthält auch quasi keine Karotte,
also enthält es auch keine
Karotte. Also hier
enthält es nichts und es ist gültig, weil
es kein Wort enthält. Für unsere letzte Analyse werden
wir uns die Behauptung der
Ausnahme ansehen, richtig Und für die Ausnahmezusicherung verwenden
wir eigentlich
den Aktionsdelegaten,
nur um das Arrangement vom Akt
vom Assert verwenden
wir eigentlich
den Aktionsdelegaten,
nur um das zu trennen Akt
vom Hier haben wir also die Handlung eigentlich der
Delegierte ist,
er ruft
den Prozesshelfer auf oder setzt ihn,
und dann handelt er bei der Assertion tatsächlich er ruft
den Prozesshelfer auf oder setzt ihn, und dann handelt er bei der Assertion Hier erwarten wir quasi eine Argument-Null-Ausnahme Wenn wir uns den
Prozesshelfer ansehen und der Wert Null ist, löst
er eine Argument-Dull-Ausnahme
aus Also, wenn ich das ausführe,
sieht Argument aus. Da ist es. Wenn ich mich also ändere, lassen Sie uns das so ändern, dass die Ausnahme nicht implementiert, sondern
implementiert wird. Wenn ich das ändere, um keine Ausnahme zu
implementieren, und es ausführe, schlägt
es fehl, weil es
keine nicht
implementierte Ausnahme auslöst. Es löst
ausnahmslos ein Argument aus. Das ist also auch ziemlich
nützlich und nett.
13. Fließende Assertionen: Hallo da. Willkommen zur Lektion
über flüssige Behauptungen. Fluent Assertions hilft
Ihnen also dabei, einfache und ausdrucksstarke Behauptungen im
Komponententest zu schreiben . Die Bibliothek enthält eine
Reihe von Erweiterungsmethoden , mit denen das gewünschte
Ergebnis eines
Komponententests spezifiziert werden kann gewünschte
Ergebnis eines
Komponententests spezifiziert Dadurch wirkt die
Assertion viel natürlicher und sie kann auch
leichter zu verstehen sein Und es hält Ihren
Code auch sauber und einfach. Weitere Dokumentationen finden Sie auf fluid assertions.com Stand 2024 gab es mehr als 446 Millionen Downloads der Fluent Assertion Library InnuGet Die Version dieses Datums ist seven.00. Diese Version kann
sich
je nach Uhrzeit ändern , zu der Sie sich dieses Video
ansehen Schauen wir uns also
an, wie wir
Fluent Assertion auf der Grundlage
unseres letzten Videos implementieren können Fluent Assertion auf der Grundlage
unseres letzten Videos In unserem letzten Video haben wir also
über Helfertests gesprochen, richtig? Wir haben alle oder die
meisten Assertions in
der X Unit-Bibliothek durchgesehen Assertions in
der X Unit-Bibliothek durchgesehen Und in diesem Video werden
wir im Grunde die Bibliothek aktualisieren oder
die
fließende Assertion zur Behauptung hinzufügen. Als Erstes klicken Sie mit
der rechten Maustaste auf Pakete verpacken in Ihrem
Unternehmen Dot Czar Lat Test, ManageNUGT-Pakete. Hier können Sie auf Durchsuchen klicken
und einfach Fluent eingeben. Sie werden Fluent Assertions sehen und Sie können Fluent Assertions einfach herunterladen Wie Sie sehen können, ist die
aktuelle stabile Version 70 Punkt
Null Null Hier haben wir
Fluent Assertions heruntergeladen, und wenn Sie sie einmal heruntergeladen haben, können
Sie sie einfach
erzwingen oder hier verwenden Also Fluent
Assertions verwenden und das war's. Wir können jetzt Fluent
Assertions in unserem Projekt verwenden. Also werde ich
hier
etwas kopieren und einfügen , nur um das Tippen zu beschleunigen Anstatt also zu sagen, dass
es wahr ist, werden
wir
weitermachen und Ergebnis sagen,
was das Objekt ist, das
wir behaupten werden
wir
weitermachen und Ergebnis sagen, wollen Und dann sollte Bankguthaben
, also diese Immobilie, als Bankguthaben erwartet
werden Wenn Sie also
Assert-Punkt-Wahle-Ergebnis vergleichen , Bankguthaben entspricht erwartetem Bankguthaben, Ergebnis Punkt
Bankguthaben
sollte erwartet werden , klingt das für mich
viel
flüssiger, zumindest tut es das, Es ist viel besser lesbar
und, wie Sie wissen, ziemlich einfach zu
verstehen, oder Wenn ich das durchführe,
können Sie sehen, dass es fehlschlägt, weil ich glaube, dass wir das in
der letzten Vorlesung geändert haben. Wenn ich das auf 150 ändere, kannst du
hier sehen, dass es fehlschlägt. Es bietet hier tatsächlich eine
Menge Details, sehen Sie,
200, aber nicht, aber es wurde ein Unterschied von
150 von 50 gefunden , das ist
also ziemlich nett. Wenn wir das jetzt ausführen, dass ich es
auf 150 ändere, ist es erfolgreich. Also lass mich
das einfach schließen. Cool. Schauen wir uns also unsere gemeinsame Behauptung zur
Gleichstellung an, richtig? Also hier haben wir so etwas
wie einen Dreizeiler, und das kannst du tatsächlich machen Es ist immer noch ein Dreizeiler, aber er ist viel flüssiger Also hier überprüfen wir
die Gleichheit, fängt damit an und
endet mit, richtig? Also suchen wir nach dem Namen. Ergebnispunktname
sollte also mit dem
erwarteten Vornamen beginnen und mit dem
erwarteten Nachnamen enden und den erwarteten Namen
enthalten. Also viel flüssiger, aus
meiner Sicht viel besser lesbar Und wenn wir das ausführen, sollten
wir
einen bestandenen Test für
die Gleichheit der Zeichenketten machen einen bestandenen Test für
die Gleichheit der Zeichenketten Da ist es.
Gleichheit der Zeichenketten, Weitergabe. Lassen Sie uns also
weitermachen und mit der numerischen Behauptung fortfahren. Also numerische Behauptung, hier suchen
wir tatsächlich
nach dem Bereich Also hier sollte das
Bankguthaben
dem vorherigen Testergebnis sehr ähnlich sein Also das sollte so als ob es überall sein wird
, und zwar im
niedrigen und hohen Bereich. Wenn ich das also kommentiere,
sollten wir sehen, dass das funktionieren
wird. Siehst du, da ist es, es funktioniert. Und dann diesen kann ich
einfach kopieren und einfügen. Ich glaube, es ist
dasselbe. schlägt
fehl, weil er
nicht innerhalb der Reichweite liegt. Also lass uns sehen, was passiert. Numerischer
Assertionsfehler, aber 150 gefunden. Ja. Also das ist so etwas wie der numerische Assertionsfehler. Schauen wir uns also unsere nächste an, die
Referenz-Assertion. Also das Gleiche hier. Das Ergebnis sollte dem Helfermodell entsprechen. In diesem Fall sollte es fehlschlagen, da es sich um eine andere
Instanz des Ergebnisses handelt. Das ist also ein Misserfolg.
Da ist es. Es schlägt fehl. Und ich glaube, das
sollte genauso sein. Dieser ist also tatsächlich erfolgreich
, weil es sich um
dieselben Objekte handelt .
Schauen wir uns das an. Das Ergebnis sollte Null sein, sehen Sie, Sie können sehen,
sollte nicht Null sein. Also könnte ich sagen: Hey,
das Ergebnis sollte nicht
Null sein und sollte dasselbe sein wie. Also kann ich diese beiden kommentieren. Lass das mal laufen,
schau, was passiert. Da hast du's. Die
Referenzzusicherung ist erfolgreich. Lassen Sie uns also weitermachen und zu
unserer Typzusicherung übergehen. Also für die Typzusicherung, im Grunde den vorherigen sehr
ähnlich ist Die Ergebnisse sollten also vom Typ Helper-Modell
sein. Und das ist der
Typ, den es gibt. Und
schauen wir uns das Leere an. Oh. Ergebnis: Die
Lieblings-Essens-Kollektion sollte leer sein. Und dann schauen wir uns das an, was nicht leer ist. Also sollte nicht sein oder die Suche nach leer sollte
nicht leer sein. Da ist es. Nicht leer sein, sollte
nicht leer sein. Es kommt also raus, diese Typen. Und lassen Sie uns diesen ausführen. Also dieser ist nicht leer. Und dann ist da noch dieser
, der leer ist. Da ist er. Sie bestehen beide. Und dann haben wir die Sammlung enthalten. Dieser ist also ein
bisschen anders , weil dieser
tatsächlich eine Liste verwendet. Es vereinfacht es also sehr. Anstatt Variablen zu verwenden,
wird also nur eine Liste verwendet. Also hier haben wir diese
Liste innerhalb einer Sammlung innerhalb der
erwarteten Variablen. Wir brauchen kein
Multiple Contains. Jetzt können wir einfach den Container verwenden. Also hier kann ich das auskommentieren
und ich könnte das einfach ausführen. Ich überprüfe, ob der
Tarif für die Abholung von Lebensmitteln die erwartete Liste
enthält. Und wie Sie sehen können, geht es vorüber. Lassen Sie uns weitermachen und mit
dem weitermachen . Also, dieser ist eingedämmt. Der andere ist
einfach nicht enthalten. Also im Grunde das Gleiche hier, Ergebnisse sollten so sein, als ob sie nicht
enthalten sind. Nicht enthalten. Und da ist es, wo ist es? Die Sammlung
enthält keine Behauptung. Die Sammlung
enthält keine Behauptung, und für unsere letzte
ist das Argument null Für das Argument nein heißt
es also im Grunde, dass Act die Ausnahme Argument Null
auslösen sollte Tut es. Und da ist unsere
Fluent-Assertion-Bibliothek implementiert
14. Codeabdeckung und Tipps: Hallo da. Willkommen zur
Lektion über Kälteabdeckungen und Tipps. Lassen Sie uns das noch einmal zusammenfassen Was ist Codeabdeckung? In der Softwareentwicklung ist die
Codeabdeckung, auch Testabdeckung genannt ein prozentuales
Maß dafür, inwieweit der Quellcode eines Programms
ausgeführt wird , wenn eine bestimmte
Testsuite ausgeführt wird. Viele Entwickler sagen, dass die
Codeabdeckung beim
Testen nicht sehr
nützlich ist . Worauf kommt es an, oder? Also vielleicht, wenn Sie
die Geschäftslogik testen möchten usw. Codeabdeckung sollte jedoch nicht als prozentuales Ziel verwendet
werden sollten Tools für die Codeabdeckung verwendet
werden, damit Entwickler verstehen, welche Teile nicht abgedeckt
sind und warum. Zunächst haben wir also die
Netzabdeckung, richtig? Also Entwickler, die eine
Leitungsabdeckung in
mindestens einem Testfall erreichen wollen Leitungsabdeckung in
mindestens einem Testfall der
die zu testende Leitung abdeckt. Es spielt keine Rolle, ob diese Zeile eine komplexe
If-Anweisung für,
Sie wissen schon, voller Bedingungen
enthält . Wenn ein Test
diese Zeile in irgendeiner Weise berührt, kann
der Entwickler
diese Zeile als abgedeckt betrachten. Wir bieten auch Zweigstellen an, was
der Tatsache Rechnung trägt, dass, Sie wissen schon, Verzweigungsanweisungen
wie Wenns, Vieren, Whiles und dass das
Programm, wissen Sie,
diese Befehle bewirken, dass sich
das Programm unterschiedlich
verhält, je nachdem wie die Wenn Sie zum Beispiel die Aussage A, if, A und B, A oder B
haben könnten, reicht es aus, zumindest einen Testfall für
die Bedingung
wahr und falsch zu
haben die Bedingung
wahr und falsch zumindest einen Testfall für
die Bedingung
wahr und falsch zu
haben, um davon auszugehen, dass
der Zweig abgedeckt ist. Und dann haben wir auch die
Fine-Code-Coverage-Erweiterung. Diese Erweiterung unterstützt also
die.net-Kernprojekte
und.net-Framework-Projekte die.net-Kernprojekte
und.net-Framework-Projekte Und es ist eine Erweiterung
, die Sie in der Visual
Studio Community Edition
verwenden könnten in der Visual
Studio Community Edition
verwenden Sie ist kostenlos und hilft
uns, die Codeabdeckung
für unsere Anwendung zu verstehen und zu
bewerten. Schauen wir uns also den Code aus
der vorherigen Lektion an und sehen wir uns an, wie wir die Codeabdeckung anhand der
feinen Codeabdeckung
messen können . Hier haben wir also das Projekt
oder die Unit-Testing-Lösung. Das erste, was
Sie tun möchten, ist Fine Code Coverage zu
installieren. Dazu klicken Sie auf Erweiterungen, verwalten Sie Erweiterungen und
suchen
dann nach Fine Code Coverage. Es gibt eine Abdeckung für Feincode. In diesem Fall ist es
bereits installiert, aber Sie können einfach auf Installieren
klicken. Ich werde hier auf dieses
Color TweakERP klicken. Sie sehen, dass es eine Schaltfläche zum
Installieren gibt. Wenn Sie es also nicht installiert
haben, sollte
es eine
Installationsschaltfläche geben, und es wird sozusagen für Sie
installiert. Hier haben wir einen Screenshot
, wie es aussieht, oder? Lassen Sie uns also weitermachen
und dieses Tool ausführen. Um das Tool auszuführen, klicken Sie auf Ansicht. Suchen Sie nach anderen Fenstern, und dann sollten Sie hier
die Codeabdeckung sehen. Um
diese Ausgabe hier tatsächlich zu haben, müssen
wir unsere Tests ausführen. Lassen Sie uns also weitermachen
und unsere Tests durchführen. 13 Durchläufe als gescheitert. Die beiden, die
scheitern, sind die, von denen
wir erwartet hatten, dass sie scheitern würden. Aber schauen wir uns an, wonach
wir hier suchen wollen. In unserem Quellcode haben
wir also das Helper-Modell. Wir haben den Helper und wir
haben die Calculator-Klasse. Und dann können Sie
sehen, dass die
Rechnerklasse
zu 100% abgedeckt ist . Es gibt eine Abdeckung von 70,5% die Helper-Klasse und 100-prozentige Linienabdeckung
für das Helper-Modell Es fehlen Tests
innerhalb des Helpers. Wenn wir uns die
Helper-Klasse hier ansehen, lassen Sie mich einiges davon offenlegen. Wir können sehen, dass es hier
rot ist, weißt du? Siehst du, die wurden nicht getestet. Deshalb sind es 70% Und was grün
ist, wurde getestet. Also hier ist es etwa gelb, weil es sich um eine
Zweigstelle handelt, und dann bedeutet Rot,
dass es nicht getestet wurde. Ich kann also irgendwie
sehen, okay, das
sind die Linien, die ich testen
muss, oder? Das sind die Linien
, die fehlen, und das ist ein Zweig, den
ich vielleicht in Betracht ziehen möchte. Es ist ein ziemlich nettes Tool. Es hilft Ihnen
zu verstehen,
wissen Sie ,
was abgedeckt wurde und was nicht. Wissen Sie, Sie können die Ergebnisse
überprüfen. Sie können nach Filialen suchen, Netzabdeckung
überprüfen, die Prozentsätze
überprüfen, und es ist ein wirklich fantastisches Tool.
Da ist also die Abdeckung Es gibt so etwas wie eine Zusammenfassung, es gibt einige Hotspots,
falls Sie sich einige ansehen möchten, wie die
zyklomatische Komplexität hier,
und einige Coverage-Logs Und das ist es im Grunde.
15. Unit-Test mit xUnit Review: Hallo zusammen. Willkommen zur Lektion über Unit-Tests
mit X Unit Review. Nachdem wir nun
unseren ersten Komponententest geschrieben haben, wir uns mit der X-Unit-Bibliothek befasst. Ich möchte Sie dazu anregen
,
eine Software zu schreiben, die eine Rechenoperation simuliert In der Software
möchten wir sicherstellen, dass wir die grundlegenden Operationen wie
Addieren, Dividieren und Multiplizieren haben grundlegenden Operationen wie
Addieren, Sie sollten Komponententests schreiben , die alle Funktionen und Fälle, in denen sie
bestanden wurden und nicht bestanden haben, abdecken . Danach sollten Sie sicherstellen, dass Sie
ein Tool
zur Codeabdeckung ausführen , damit Sie Codeabdeckung
für Ihre Codebasis messen
können. Dann ermutige ich Sie, Ihre Ergebnisse auf
GitHub zu veröffentlichen. Lassen Sie uns diesen Abschnitt zusammenfassen. Wir haben mit den
ersten Schritten mit X Unit begonnen. Ich erkläre, warum Xunit
eine so wichtige Bibliothek ist. Wir haben ein Testprojekt erstellt
und Visual Studio erkundet. Wir haben unseren ersten Komponententest geschrieben. Wir haben uns den
Komponententest mit dem Test Explorer angesehen und
ihn im Test Explorer ausgeführt. Wir haben unsere Tests
mit dem A-Muster formatiert
, einem häufig verwendeten Standard Wir haben auch die Kältedecke
und einige grundlegende Tipps analysiert. In dieser Lektion sollten
Sie in der
Lage sein, bequem Unit-Tests zu
schreiben,
Cold-Coverage auszuführen und grundlegende Formatierungen
für Ihre Tests zu
haben.
16. Sozialversicherungsnummernvoraussetzungen: Hallo da. Willkommen zur Lektion über die Anforderungen an
Sozialversicherungsnummern. Lassen Sie uns also über
Softwareanforderungen sprechen. Softwareanforderungen sind
ein sehr wertvolles Artefakt , wenn es um
Softwaretests geht Anforderungen den Anforderungen gehören die funktionalen oder
nichtfunktionalen Einschränkungen , die die Software bieten
muss, um die Bedürfnisse von Benutzern
und anderen Beteiligten zu erfüllen Anforderungen sagen uns
genau, was die Software tun
muss und was
nicht. Sie beschreiben die Feinheiten der Geschäftsregeln
,
die die Software
implementieren muss , und beschreiben, wie
sie gültig sein sollten Daher sollten die
Anforderungen
das erste Artefakt sein , das
Entwickler beim
Testen
berücksichtigen beim
Testen
berücksichtigen Wir werden eine
Testsuite mit X Unit
in Visual Studio auf
der Grundlage der angegebenen Anforderungen erstellen in Visual Studio auf
der Grundlage der angegebenen Anforderungen Wir werden
eine Anwendung erstellen, die einen Benutzer in eine Datenbank
einfügt. Wir werden
die folgenden Daten verwenden den Vornamen des Benutzers, den Nachnamen des
Benutzers, das Geburtsdatum des und die
Sozialversicherungsnummer des Benutzers. Benutzer zwischen
zehn und 80 Jahren dürfen das System
nutzen, und die
Sozialversicherungsnummer muss gültig sein. Was die Datenbank betrifft, werden
wir nicht
die eigentliche Einfügung implementieren, werden
wir nicht
die eigentliche Einfügung implementieren,
sondern wir werden etwas implementieren, das einer Einfügung
der Datenbank nachempfunden wäre . Und das werden Sie sehen,
sobald wir mit dem Programmieren beginnen. Für die Anforderungen an die
Sozialversicherungsnummer sind dies die Anforderungen. Zunächst
sollte die
Sozialversicherungsnummer dem
folgenden Format folgen. Der erste Teil wird
als Gebietsnummer bezeichnet. Der zweite Teil wird
als Gruppennummer und der letzte Teil als Seriennummer
bezeichnet. Die Bereichsnummer besteht aus
drei Ziffern und darf nicht 000666 oder 900-999
sein Die Gruppennummer darf nicht 00 sein, und es ist auch eine
zweistellige Zahl, und die Seriennummer ist eine vierstellige Zahl
und darf nicht Cool. Schauen wir uns einen Code an. Als Erstes habe ich
hier
einen Ordner
mit Sozialversicherungsnummern in der Business Dot Cesar-Klasse erstellt einen Ordner
mit Sozialversicherungsnummern der Business Dot Cesar-Klasse Dazu können Sie mit der rechten
Maustaste auf das Projekt
klicken, auf Hinzufügen und dann auf Neuer Ordner und dem
Ordner dann einfach einen beliebigen Namen geben In meinem Fall habe ich es SSN genannt
, was für
Sozialversicherungsnummer steht Jetzt klicken wir auf den Ordner,
klicken auf AD und fügen eine neue Klasse Ich werde
diese Klasse Benutzer nennen. Richtig, jetzt werde ich ein Modell für den Benutzer
erstellen, also werde
ich es einfach öffentlich machen
und
einige Eigenschaften erstellen. Also werde ich zuerst den Vornamen
erstellen. Lass uns den Nachnamen haben. Lassen Sie uns das Datum
bis zum
Geburtsdatum haben bis zum
Geburtsdatum . Home. Lassen Sie uns weitermachen und
die Sozialversicherungsnummer haben. Wir haben also den Vornamen
String, den Nachnamen String, Geburtsdatum als Datum/Uhrzeit und die
Sozialversicherungsnummer als Zeichenfolge Cool. Das ist also unsere Benutzerentität , mit der wir arbeiten
werden. Jetzt werde ich
eine Benutzerdatenklasse erstellen, die für das
Einfügen des Benutzers
in die Datenbank verantwortlich ist Einfügen des Benutzers
in die Datenbank Lassen Sie uns also weitermachen und
eine Klasse namens Benutzerdaten erstellen. Ich werde
es veröffentlichen ,
alles öffentlich machen. Lassen Sie uns also weitermachen und eine Methode
namens Insert-Benutzer benennen oder erstellen. Also public void Benutzer einfügen. Ich habe meine
Keyword-Einstellungen geändert. Ordnung, also public
void insert user, und der Parameter dafür
ist eigentlich der Benutzer. Cool. Wir haben also einen Benutzer
als Parameter und die Datenbank
interessiert uns nicht wirklich,
also sage ich einfach, wirf die Implement-Exception
raus. Wir simulieren eine Einfügung, aber die Datenbank interessiert
uns nicht wirklich Denken Sie daran, bei diesen Unit-Tests sind uns
Integrationen egal Eine Datenbank ist also eine Integration
in ein externes System, richtig, das Daten enthält, und das
interessiert uns nicht wirklich Wir benötigen
diese Methode jedoch, da wir eine
Einfügung in die Datenbank simulieren werden Wir machen uns also darüber lustig, oder? Also werden wir in den nächsten Lektionen
darüber sprechen, aber lassen wir
es vorerst so Wir haben also die Benutzerdaten. Und zu guter Letzt erstellen
wir eine
Sozialversicherungsnummernklasse. Also werde ich
eine neue Klasse erstellen und sie Sozialversicherungsnummer
nennen. Ich werde
es auch öffentlich zugänglich machen. Cool. Und ich werde eine
Methode namens Insert-Benutzer erstellen. Also public void user einfügen. Wenn wir diese
und irgendeine Art von
strukturierter Architektur entwickeln würden , könnten
wir diese Klassen
auf einer anderen Ebene haben. Aber an dieser Stelle würde ich es
einfach einfach halten, oder? Wir haben also eine Methode
, um den Benutzer einzufügen. Ich werde auch eine
Methode von TableAnPublic Bowl erstellen und sie als
gültige SSN- oder Sozialversicherungsnummer bezeichnen ,
was im Grunde genommen die
Sozialversicherungsnummer validiert Also
Sozialversicherungsnummer, richtig? Ich nehme das
vorerst, gib einfach Falsch zurück. Und lass uns weitermachen und ein
Verpassen. Da hast du es. Lassen Sie uns weitermachen und diese Methode
implementieren. Also der oder der Benutzer fehlt hier. Der Insert-Benutzer
verwendet also das Benutzermodell. Also, wenn das oder, falls nicht gültig, der
Benutzerpunkt Sozialversicherungsnummer ist , oder wenn die
Sozialversicherungsnummer nicht gültig ist, werden
wir weitermachen
und eine neue Ausnahme auslösen. Sagen wir einfach eine
Ausnahme für ungültige Daten und ich werde versuchen, mich an diese Tastatur
zu gewöhnen. Ordnung. So cool. Wir haben eine Ausnahme für ungültige Daten, also sage ich hier einfach
ungültige SSN. Richtig. Cool. Jetzt werden wir neue Benutzerdaten
instanziieren. Das ist meine Datenmethode,
die
dafür verantwortlich ist,
einen Benutzer in die Datenbank einzufügen , nur um unseren Anforderungen
zu entsprechen Also, wenn die Sozialversicherungsnummer gültig
ist, möchte ich sie einfügen Also werde ich
weitermachen und sagen:
Hey, füge meinen Benutzer in
die Datenbank ein. Jetzt habe ich sozusagen mein Grundgerüst
der Anwendung, in dem
ich meine Entität habe. Modell. Ich habe mein Datenmodell und ich habe meine Geschäftslogik, in der ich
die Validierung und
das Einfügen
des, Sie wissen schon, Benutzers implementiere . Also innerhalb dieses oder
mit diesem Grundgerüst werden
wir
all unsere Unit-Tests implementieren. Und natürlich werden wir
tatsächlich die
eigentlichen Validierungen implementieren, und Sie werden das in
den nächsten Lektionen sehen den nächsten Lektionen wir
unsere Anforderungen implementieren und testen
17. Mocking-Datenzugriff mit MOQ: Hallo, willkommen zur Lektion „Mocking
Data Access An dieser Stelle ist es uns also
nicht wirklich wichtig, den Benutzer in
die eigentliche Datenbank
einzufügen Es ist uns wichtig, die Regeln für
Sozialversicherungsnummern zu testen. Selbst wenn die Implementierung für die Benutzerdaten fertig
wäre und wir eine Datenbank auf
Unittest-Ebene einsatzbereit
hätten, ist es
uns egal, ob wir eine
Verbindung zu einer Datenbank herstellen. Denken Sie daran, dass dies kein
Integrationstest ist. Die Lösung hier besteht also darin
, sich über Benutzerdaten lustig zu machen. Und um das zu tun, müssen
wir Daten oder
eine Benutzerdatenschnittstelle erstellen und diese Schnittstelle
dann
in den Code einfügen Und das werden wir uns
im Code ansehen. Ähm, wir haben also das
MQ-Paket oder das Mock-Paket, MQ. Es ist eine beliebte Bibliothek
zum Verspotten in.net. Sie ist derzeit auf Version 4.272
und es gibt mehr als
730 Zusammenfassend lässt sich sagen, dass ein Scheinobjekt erstellt
wird, um
das Verhalten
eines realen Objekts zu simulieren , um
die Funktionalität anderer
Softwarekomponenten zu testen die Funktionalität anderer , die davon abhängen In unserem Fall
wollen wir also quasi
das Einfügen des Benutzers
in die Datenbank verspotten , oder? Ähm, hier haben wir unser Benutzerdatenvertrag aussehen
wird, also werden wir
einfach im Grunde
eine Schnittstelle namens I user data erstellen , und dann werden
wir
diese Schnittstelle irgendwie verwenden und
sie in unseren Code einfügen Also werden wir Automok verwenden
, nur
um die
Abhängigkeitsinjektion, die Auflösung
der
Abhängigkeitsinjektion, zu erleichtern , und das geht
etwas tiefer, aber es
automatisiert im Grunde unser Mocking Aktuell hat
Automoc also 15 Millionen Downloads. Es ist quasi ein spöttischer
Container für M, und es hilft wirklich, wenn
Sie
quasi in die Umkehrung der Kontrolle investieren und
Ihren Komponententest, Sie wissen schon, Änderungen an den Konstruktionsargumenten entkoppeln wollen Sie wissen schon, Änderungen Also lass uns weitermachen und uns hier etwas
Code ansehen. also hier bei den Benutzerdaten Wenn Sie also hier bei den Benutzerdaten auf
Benutzerdaten und dann auf den
Kontrollpunkt klicken und die Benutzeroberfläche
extrahieren, wird im Grunde
eine Schnittstelle namens I Benutzerdaten erstellt . Für uns automatisiert es die Erstellung
der Benutzeroberfläche, und dann können wir die E-Benutzerdaten irgendwie verwenden oder in
die Sozialversicherungsnummer einfügen Also werde ich weitermachen
und einen Konstruktor erstellen. Hier werde ich
eine private Variable erstellen. Ich werde das injizieren
. Da hast du's. Benutzerdaten, und dann werde
ich diese Benutzerdaten hier als
meinen Vertrag verwenden , anstatt eine neue Klasse
zu instanziieren Also hier und jetzt
habe ich einen Vertrag,
du weißt schon, eine Benutzerdatenschnittstelle Und außerdem ist meine
Struktur jetzt gewissermaßen nicht gekoppelt, aber, wissen
Sie, sie hat diese
Abhängigkeit davon. Automa hilft uns also irgendwie, diese Abhängigkeit
zu lösen. Es
löst das einfach auf magische Weise für uns. Also lass uns weitermachen und all das
schließen,
speichern, schließen und lass uns weitermachen und uns unseren Test ansehen Hier versuchen wir,
die
Sozialversicherungsnummernklasse zu testen . Klicken wir mit der rechten Maustaste auf das Projekt, klicken wir auf AD und fügen dem
Testprojekt grundsätzlich einen
Sozialversicherungsnummerntest hinzu. Lassen Sie mich das in
Sozialversicherungsnummerntest umbenennen. Wir haben den Test der
Sozialversicherungsnummer. Lassen Sie mich also weitermachen und aus
Produktivitätsgründen einen Code hier kopieren . Also hier haben wir Auto Marker. Also werde ich auf
Pakete Nugget-Paket hinzufügen klicken. Ich suche nach Mc und füge dann
das M hinzu oder installiere die Mc-Bibliothek Derzeit auf Version
vier Punkt 20. Die Art,
all diese Tests zu bestehen. Ich werde auch den Mu Automoc
hinzufügen. Installieren Sie also
diese beiden Bibliotheken. Dies sind die Bibliotheken, die
wir verwenden werden. cool. Also haben wir MQ,
wir haben Mach Automoc Also, wenn wir zu unserem Test zurückkehren und ich das hier
kontrollieren möchte, können
Sie sehen, wie Sie
Automoc benutzen Also hier benutzt es jetzt Automoc. Und bei der Konstruktion des Tests zur Sozialversicherungsnummer, bei
der Instanziierung,
Sie wissen schon, oder bei der Beibehaltung
dieses Objekts,
quasi globales Recht
auf Also muss ich das jedes
Mal oder für jede Methode neu erstellen Mal oder Also hier habe ich meine Automrkers,
eine globale Variable, und ich werde
weitermachen und
eine Methode namens Benutzer einfügen erstellen eine Methode namens Benutzer einfügen Also habe ich diese Methode hier. aufgerufene Insert-Benutzer sollte keine Ausnahme
auslösen
, wenn der Benutzer eingefügt wird. Jetzt möchte ich es wissen, ich möchte sicherstellen, dass es keine
Ausnahme auslöst, oder? Denken Sie also daran, dass beim
Aufrufen der Benutzerdaten tatsächlich eine Ausnahme ausgelöst wird Wenn ich zur Implementierung gehe, erzwingt
sie die Ausnahme Wir möchten sicherstellen, dass diese Ausnahme nicht ausgelöst
wird. Dafür werden
wir als Erstes eine private
Methode namens Create User erstellen, die uns helfen wird,
Benutzer mit einer
Sozialversicherungsnummer
zu erstellen . Diese Methode gibt also einen Benutzer zurück. Es hat als Parameter
die Sozialversicherungsnummer gibt lediglich ein Objekt
mit dem Vornamen,
Nachnamen, Geburtsdatum und
der angegebenen
Sozialversicherungsnummer zurück Nachnamen, Geburtsdatum und
der . Es ist also quasi
wie ein Schöpfer für uns. Also das wird
das Objekt für uns erschaffen, und ich werde es verwenden, um unsere Verspottung zu arrangieren und einzurichten Schauen wir uns hier also unser Sortiment an. Nicht dieser, es ist
dieser hier. Schauen wir uns dieses Arrangement hier an. dieser Anordnung
haben wir den Benutzer mit gültigem Social Media, den wir
mit der Methode Create User erstellt haben. Dabei wird lediglich ein Benutzer mit
einer gültigen
Sozialversicherungsnummer
erstellt , wobei wir dann mit unserem Auto-MAC eine Instanz
der
Sozialversicherungsnummer instanziieren unserem Auto-MAC eine Instanz
der
Sozialversicherungsnummer Objekt. Das erzeugt also eine Instanz und löst die
Abhängigkeit für uns Und dann haben wir sozusagen unseren automatischen Mock
eingerichtet. Also das ist unser M, richtig? also jedes Mal, wenn
Benutzerdaten aufgerufen Wir wollen also jedes Mal, wenn
Benutzerdaten aufgerufen werden, sicherstellen dadurch keine
Ausnahme ausgelöst wird, oder? Wir wollen also sichergehen
, dass
wir, wenn das aufgerufen wird, den Insert-Benutzer für
diesen Benutzer mit gültigen sozialen Netzwerken tatsächlich verspotten . Das wird also
verhindern, dass Spott gemacht
wird, das verhindert, dass eine Ausnahme ausgelöst wird, weil wir diese Methode nicht wirklich
aufrufen werden Wir werden uns über die Methode des
Antwortbenutzers lustig machen. Jetzt können wir also handeln, oder? Also denken Sie daran,
wir testen , wir wollen sichergehen, dass wir
keine Ausnahme auslösen, also werden wir hier einen Delegierten
verwenden Deshalb werden wir hier agieren oder den Antwortbenutzer
als Delegierten aufrufen,
und das wird
uns helfen, nach Ausnahmen zu suchen, wie wir bereits
bei der Ausnahme gesehen haben Und was die
Behauptung angeht, wollen
wir im Grunde nur
sichergehen, dass sie
keine Ausnahme auslöst, oder Lassen Sie uns also weitermachen
und diesen Test durchführen. Und es schlägt fehl. Es löst
eine ungültige Ausnahme aus Schauen wir uns unsere Methode zum
Einfügen von Benutzern und sie gibt tatsächlich
eine ungültige
Sozialversicherungsnummer zurück eine ungültige
Sozialversicherungsnummer Ich werde das auf
true setzen, damit wir
diese Validierung bestehen können. Natürlich
werden wir
den Code zur Validierung der
Sozialversicherungsnummer implementieren . An dieser Stelle werde ich nur
sichergehen, dass mein Test bestanden wird. Ich werde das vorerst auf
wahr setzen, lassen Sie uns weitermachen und das erneut ausführen und sollten hier diesen
Breakpoint Also hat es getroffen, es
hat diese Methode aufgerufen und all das
getroffen, und das ist markiert Das wurde umgangen und ich habe den
Benutzer zum Einfügen von Benutzerdaten
erfolgreich verspottet, was im Grunde
das ist, wonach ich
in dieser Lektion gesucht habe Wir haben das erfolgreich verspottet
und in der nächsten Lektion werden
wir weitermachen und einen Teil
unserer
Geschäftslogik implementieren
18. Unitentests der Anforderungen Teil 1: Hallo zusammen. Willkommen zur ersten Lektion über Unit-Tests
der Anforderungen. In dieser Lektion
werden wir
die Anforderungen durchgehen und die Altersvalidierung
implementieren. Also haben wir
die Anwendung implementiert , die einen Benutzer
in eine Datenbank einfügt, und wir haben auch
das Modell implementiert , das wir in die Datenbank
einfügen. Wir haben also den
Vornamen, den Nachnamen, das Geburtsdatum und die Sozialversicherungsnummer des
Benutzers. In dieser Lektion werden wir
weitermachen und
die Validierung des
Alters dieses Benutzers implementieren . Benutzer zwischen
zehn und 80 Jahren sind also im System erlaubt. Schauen wir uns also
einen Code an. Hier haben wir also
unsere Codebasis mit
unserem Komponententest und
dem Create-Benutzer. Als Erstes werde
ich also einen neuen Test erstellen,
um tatsächlich
zu versuchen, einen Benutzer
einzufügen , der jünger als zehn Jahre
ist. Also werde ich weitermachen
und diesen Test einfügen. Hier drüben, damit wir es schnell
durchgehen können. Hier haben wir also eine Methode
namens Insert-Benutzer, eine Ausnahme auslösen sollte wenn das Alter jünger als zehn Jahre ist. Denken Sie daran, dass die
Altersgruppe älter als zehn Jahre sein muss. Also habe
ich im übersichtlichen Abschnitt eine Variable implementiert, die ein Datum
erhält, das zwischen zehn und einem
Tag liegt, richtig? Also du bist 10 Jahre alt plus eins,
das heißt, du bist neun Tage
und einen Tag von zehn entfernt Dann werden wir anhand dieses Datums
einen Benutzer erstellen. Lassen Sie mich weitermachen
und den Code
für die Erstellung des Benutzers auf der
Grundlage des Datums erstellen. Dieser Code hier erstellt einen Benutzer
basierend auf dem Geburtsdatum. Das Gleiche wie dieser, dieser erstellt auf
der Grundlage der Sozialversicherungsnummer, wie Sie
hier sehen können, und dieser
erstellt einen Benutzer
auf der Grundlage des Geburtsdatums. Cool. Also haben wir
hier einen Benutzer mit einem ungültigen Alter erstellt. Wir haben unsere Mc-Instanz
in unserem Benutzerdaten-Mooc erstellt. Lassen Sie mich weitermachen und
dies aktualisieren, um den Benutzer einzufügen. Und dann
behaupten wir im Grunde, dass dies eine ungültige
Datenausnahme auslösen
sollte Lassen Sie mich diesen Test durchführen
und sehen, was passiert Cool. Wie erwartet ist der Test
fehlgeschlagen, weil wir die Logik
für die Altersvalidierung nicht
implementiert haben. Schauen wir uns also die Codebasis
an, oder? Schauen wir uns also die
Sozialversicherungsnummernklasse
an. Diese Art der
Implementierung ist also etwas , das in TDD, genauer gesagt, in der
testgetriebenen Entwicklung verwendet wird , wo
Sie zuerst Ihre Tests schreiben, sie schlagen fehl, und dann
schreiben Sie den Code, um das Problem zu beheben Das ist wirklich hilfreich, weil
der Test tatsächlich bestätigt, wonach wir
suchen, oder Wir suchen nach einer Ausnahme wenn das Alter
jünger als zehn Jahre ist Und wir haben es
noch nicht implementiert, also warnt es uns quasi :
Hey, du musst
das implementieren, bevor du weitermachen kannst. Es ist also eine ziemlich nette
Art der Entwicklung. Lassen Sie uns also weitermachen und die Altersvalidierung
implementieren. Also werde ich weitermachen
und
wieder etwas Code einfügen, nur aus
Produktivitätsgründen. Und dann können wir den Code
durchgehen. Das ist also ein Altersprüfer. Es ist im Grunde eine Schüssel,
die, du weißt schon,
zurückgibt, ob das Alter
gültig ist, ob es wahr ist oder Hier gibt es eine Methode namens Get Age, mit der wir das Alter ermitteln. Das berechnet also das Alter
anhand des Geburtsdatums. Und wenn das Alter dann kleiner als
80 oder größer als
oder gleich zehn
ist , ist
eine Rendite wahr, Es muss also 10-80 Jahre alt sein. Und jetzt können wir dieses
gültige Alter in unserer
Codebasis verwenden gültige Alter in unserer
Codebasis Also kann ich das benutzen. Ich kann hier tatsächlich
eine IF-Aussage haben. Ich habe ein gültiges Alter und wir können das
Geburtsdatum herausfinden. Wenn es nicht gültig ist oder
wenn das Alter nicht gültig ist, können wir eine
ungültige Datenausnahme auslösen. Und sagen wir einfach
ungültiges Alter. Cool. Jetzt haben wir also unsere
Altersvalidierung. Machen wir also weiter und
führen diesen Test erneut durch. Und da hast du's. Die
Altersvalidierung ist bestanden, richtig? Also haben wir unsere Logik implementiert, wir haben unseren Komponententest implementiert und das Alter unter 10
Jahren bestätigt, richtig? Und jetzt ermutige ich Sie
, einen Komponententest zu schreiben, um das
andere Alter als 80 zu überprüfen Damit wir die
Geschäftsregeln einhalten können.
19. Unitentests der Anforderungen Teil 2: Hallo da. Willkommen zur Lektion
zum Testen
der Anforderungen in Einheiten, Teil zwei. Sehen wir uns also
die Anforderungen an. Wir haben zunächst eine Anwendung erstellt , die einen Benutzer
in eine Datenbank einfügt. Anschließend haben wir die
folgenden Daten eingefügt: Vorname, Nachname, Geburtsdatum und Sozialversicherungsnummer des Benutzers. Wir haben das Alter bestätigt, das unter zehn Jahren liegt, und
fahren dann mit der
Sozialversicherungsnummer fort . Eine
Sozialversicherungsnummer muss also gültig sein. Dafür haben wir die
folgenden Regeln, oder? Die
Quellsicherheitsnummer hat das Format einer dreistelligen Zahl, einer zweistelligen
Zahl, einer vierstelligen Zahl. Der erste Teil wird
als Bereichsnummer bezeichnet. Der zweite Teil wird
als Gruppennummer und der letzte Teil als Seriennummer
bezeichnet. Die Bereichsnummer darf nicht
000-66-6999 oder 900 oder 999 sein. Die Gruppennummer
darf nicht 00 und die Seriennummer
darf Lassen Sie uns also weitermachen und
uns einen Code ansehen. Wir werden also einen TDD-Ansatz
verfolgen und zuerst
den Komponententest schreiben und dann unsere Validierung
implementieren Aus Produktivitätsgründen werde
ich also weitermachen
und einen Code bezahlen, und wir werden diesen Code
durchgehen Also habe ich eine Theorie entwickelt
, die das Gebiet testet. Ich teste für einen Bereich, der mit 000666 900 oder 999
beginnt. Und im Grunde ist der Name
der Methode oder ja, der Name der Methode der Name
der zu
testenden Methode und dann, was Sie wissen,
sollte eine Ausnahme ausgelöst werden Wir erwarten also eine Ausnahme
, wenn der Bereich ungültig ist. Hier haben wir also
eine Sozialversicherungsnummer erstellt , die
auf den Inline-Datenparametern basiert . Also all diese sind ungültig. Wir haben den Mc für die Social Security
Number Business Class, und dann haben wir den Mc
für die Eye-Benutzerdaten. Ich mache weiter und
repariere diesen Insert-Benutzer, und wir rufen unsere Aktion auf und
erwarten eine Ausnahme. Wenn ich also diesen
Komponententest durchführe , lassen Sie mich das erweitern. Es löst keine Ausnahme aus. Es löst tatsächlich eine
Ausnahme aus. Schauen wir uns das an Es löst also tatsächlich
eine Ausnahme aus. Schauen wir uns unseren Create-Benutzer anhand des
Geburtsdatums oder der
Sozialversicherungsnummer an. Das Geburtsdatum
ist jetzt also Datum und Uhrzeit. Das bedeutet, dass der Benutzer jünger als zehn Jahre
ist. Also lass uns weitermachen und das beheben. Lassen Sie mich sagen, addieren Sie Jahre -11 Lassen Sie uns weitermachen und das
noch einmal ausführen. Und da hast du's. Nun, es wird nicht wie erwartet eine
Ausnahme ausgelöst, weil der Bereich nicht innerhalb
unserer Geschäftslogik validiert
wird. Lassen Sie uns also weitermachen und
uns das Gebiet hier ansehen. Wenn wir also zur gültigen
Sozialversicherungsnummer gehen, können
wir sehen, dass wir noch keine Implementierung
haben. Als Erstes werden wir also die
Logik für den Bereich implementieren. Also lass mich weitermachen
und einen Code bezahlen. Also das Erste, was
wir hier gemacht haben , war die ersten drei Ziffern der Sozialversicherungsnummer zu finden. Wir erhalten also die
ersten drei Ziffern, die für das Gebiet stehen. Und wenn der Bereich 000666
900 oder 999 ist, geben wir falsch zurück. Und im Grunde wird das Gebiet
validiert, oder? Jetzt haben wir also die
Gebietsvalidierung. Gehen wir zurück zu unserem
Komponententest und führen ihn aus. Und da hast du's. Es wurden keine
Ausnahmen ausgelöst. Tatsächlich wurden Ausnahmen ausgelöst und der Test bestanden, oder? Wir erwarten also
, dass eine Ausnahme ausgelöst wird, denn wenn die
Quellsicherheitsnummer ungültig ist, wird eine
ungültige Cool. Lassen Sie uns also weitermachen
und zu unserer Gruppe übergehen. Lassen Sie uns also den
Komponententest für unsere Gruppe erstellen. werde ich
hier
nach unten scrollen, damit Dafür werde ich
hier
nach unten scrollen, damit ich das einfach schließen kann. Scrollen Sie also hier nach unten und
erstellen Sie diese Methode. Dieser heißt also
einfügen. Der Benutzer sollte bei einer ungültigen Gruppe eine
Ausnahme auslösen. Eine ungültige Gruppe kann also nicht die Ziffer 00
enthalten. In diesem Fall
werde ich das aktualisieren, den Benutzer
einfügen und Walla,
da haben wir es Lassen Sie mich das ausführen, und das ist nicht so, dass es keine
Ausnahme auslöst , weil
wir die Gruppe tatsächlich nicht
validiert haben ,
also ist sie fehlgeschlagen, oder Wir erwarten eine Ausnahme, aber es wurde keine
Ausnahme ausgelöst Gehen wir also zurück zur Überprüfung
der
Sozialversicherungsnummer und implementieren wir die Logik
für die Gruppenvalidierung, die hier sehr ähnlich ist. Also werden wir die
Teilzeichenfolge für die Gruppe abrufen. Es ist also dazwischen, es
beginnt mit Index vier und hat eine Länge von zwei Diese Methode ruft also die
Teilzeichenfolge für die Gruppe ab, und wenn sie 00 ist, gibt
sie falsch zurück Ich kann einfach hier klicken
und meinen Test ausführen. Und da hast du es. Es wird eine Ausnahme ausgelöst, sodass der Test erfolgreich ist. Und zu guter Letzt lassen Sie uns weitermachen und unseren
Komponententest
für die Validierung der
Seriennummer implementieren . Sehr ähnlich
den vorherigen. Lassen Sie mich das minimieren. Der Insert-Benutzer sollte bei
einer
ungültigen Seriennummer eine Ausnahme auslösen . Lassen Sie mich das korrigieren. Benutzer einfügen.
Hier suchen wir also nach einer Seriennummer, die 0000
entspricht. Wenn das der Fall ist,
sollte es eine Ausnahme auslösen. Wir würden also eine Ausnahme erwarten. Wenn ich diesen
Komponententest durchführe, sollte er fehlschlagen. Es schlägt fehl, weil wir das noch nicht
implementiert haben. Und wenn wir
zur Implementierung zurückkehren, können
wir weitermachen und diesen Teil einfach
implementieren. Also hier werde ich den seriellen Abschnitt
erstellen. Wir werden die
letzten drei Ziffern ermitteln. Und wenn die letzten drei Ziffern gleich Null, Null, Null sind, dann geben wir Falsch zurück, und das wird hier eine
Ausnahme auslösen, oder? Also, wenn ich diesen
Test noch einmal durchführe, da hast du ihn. Wir haben
unsere Testlogik auf der
Grundlage von Fehlerszenarien implementiert . Natürlich können Sie Szenarien untersuchen, die
bestanden wurden und nicht bestanden haben. Ich beginne immer gerne mit
den Fehlschlagszenarien, aber dann kannst du hier noch mehr
erforschen. Bei dieser Art von
Unit-Tests mit dieser Art
von Implementierung ist
es viel sicherer, Änderungen
vorzunehmen, oder? Ich kann problemlos Änderungen
an der Geschäftslogik vornehmen. Und führe meine NICS aus, um
sicherzustellen, dass
alle Validierungen, die
auf meinen Anforderungen basieren Also, wissen Sie, das gibt
Entwicklern, Sie wissen schon, es gibt Softwareingenieuren
ein Gefühl Wissen Sie, Sie können Ihre Software
weiterentwickeln. Sie können mit Ihrer
Software arbeiten und sicherstellen, dass, Sie wissen schon, die grundlegenden Funktionen grundlegenden Anforderungen erfüllt
werden.
20. Unitentests der Anforderungen Teil 3: Hallo, Leute. Willkommen zur Lektion über Unit-Tests
der Anforderungen P drei. Also haben wir unsere
Gebietsgruppe und die Nullvalidierung implementiert. Es fehlt jedoch immer noch eine Bestätigung für die
Sozialversicherungsnummer. Wir haben das Format
der
Sozialversicherungsnummer noch nicht getestet . Lassen Sie uns das also umsetzen. Lassen Sie mich weitermachen und
diesen kopieren , weil
wir die Theorie verwenden werden, und ich werde ihn hier einfügen. Ich werde sagen, dass der Insert-Benutzer bei einem ungültigen Format eine Ausnahme auslösen
sollte. Cool. Lassen Sie mich weitermachen und ein paar
ungültige Formate testen. Also werde ich AAA eins, zwei
sagen. Also das ist ein ungültiges
Format. Lass uns das hier sehen. Eins, zwei, drei,
statt eines Gedankenstrichs gebe ich eine Zahl ein,
damit ich die Bindestriche nicht habe Lass uns hier nachdenken. Lassen Sie uns Null Null
als gültiges Format verwenden. Lassen Sie uns auch leer sein. Lassen Sie uns das einfach laufen , um zu sehen, was
passiert, oder? Wir haben also
keine Formatvalidierung implementiert. Mal sehen, ob für keine dieser Optionen eine Ausnahme
ausgelöst wird , dann
haben wir, weißt du, bereits ein paar Fehler. Lassen Sie uns das ausführen
Damit für diesen Damit Fall keine
Ausnahme
ausgelöst wird, und für den
scheint die Null zu sein, oder? Also sind zwei unserer Testfälle gescheitert. Wir
erwarten grundsätzlich eine Ausnahme für all diese
ungültigen Formate. Und es gibt wahrscheinlich
noch viel mehr ungültige Formate
, weißt du, wenn wir darüber nachdenken oder,
du weißt schon, darüber nachdenken,
gibt es wahrscheinlich noch viel mehr du hier einfügen oder
haben kannst. Und das ist ziemlich nett, oder? Sie haben eine Methode, die etwa vier
ungültige Formate
validiert Lassen Sie uns also weitermachen und unsere Formatlogik
implementieren. Gehen wir also zu der gültigen
Sozialversicherungsnummer und als Erstes
validieren wir das Format. Also werde ich weitermachen und
diesen Code hier einfügen , damit
wir ihn durchgehen können. Und hier werden wir
eine Bibliothek namens Regex verwenden, eine Bibliothek, die uns hilft, Formate zu
validieren, die auf
regulären Ausdrücken basieren, oder Hier prüfen wir also,
ob es eine Übereinstimmung gibt, bei der die Sozialversicherungsnummer eine dreistellige Zahl
hat, und dann gibt es einen Gedankenstrich, und dann erwarte ich
eine zweistellige Und dann noch ein
Gedankenstrich und dann
erwarte ich eine vierstellige Zahl. Also im Grunde ist das eine Bestätigung für die
Sozialversicherungsnummer. Wir brauchen drei Zahlen, zwei
Zahlen, vier Zahlen. Wenn es ein Buchstabe oder etwas
anderes ist, wenn es keine Zahl ist, wenn es keinen Bindestrich gibt, dann sollte
die Validierung fehlschlagen. Lassen Sie mich also weitermachen und
diesen Test erneut durchführen. Und da hast du's. All diese ganzen Daten hier sind ungültig
und unser Komponententest hat bestätigt , dass all diese Eingaben in einer
Ausnahme ausgelöst
werden, oder? Wir erwarten also eine Ausnahme, wie Sie hier sehen können, und alle werden jetzt als Ausnahme
ausgelöst. Also haben wir das Format erfolgreich
validiert.
21. Codeabdeckung: Hey, Leute. Willkommen zur
Lektion über Codeabdeckung. Lassen Sie uns also weitermachen und
unseren Geltungsbereich für die
Umsetzung der
Sozialversicherungsvorschriften analysieren . Als Erstes klicken
wir also auf Andere Fenster
anzeigen und suchen
dann nach dem Code
Coverage. Ich werde weitermachen und auf die Registerkarte Test
klicken und
dann auf Test Explorer klicken. Ich werde die Testklassen für
die
Sozialversicherungsnummer filtern Testklassen für
die
Sozialversicherungsnummer und alle meine Tests für die Sozialversicherungsnummer durchführen. Und jetzt haben wir unseren
Geheimcode für diese Klassen. Lassen Sie uns hier die
Sozialversicherungsnummernklasse analysieren. Hier haben wir eine Leitungsabdeckung von 97,2%
und eine Codeabdeckung von 88,4%. Wenn wir den Kurs hier eröffnen, können
wir vielleicht einige Ergebnisse Hier decken wir
all diese Linien ab, wir decken all diese Linien ab. Bei der Altersvalidierung fehlt
uns die Bestätigung eines Alters über 80 oder mehr
als oder gleich 80, oder? Denken Sie also daran, dass dies
der Teil der Filiale ist, der fehlt. Und dann werden sie auch älter. Obwohl es eine private
Methode ist, fehlt uns immer noch, weißt
du, das Alter zu bekommen, was, um ehrlich zu sein, vielleicht nicht so wichtig ist. Denken Sie jedoch daran, dass Code Coverage uns dabei hilft, zu analysieren,
was wir verpasst haben, oder? Nehmen wir also an, Sie implementieren
Ihre Geschäftslogik. Sie verstehen, dass
Sie das verpasst haben, aber Sie halten es für
nicht so wichtig, oder? Vielleicht
ist Ihre eigentliche Geschäftslogik wichtiger ,
nämlich Ihre Seriennummer, Ihre Gruppe, Ihre
Gebietsvalidierung Natürlich ist Ihre
Altersvalidierung wichtig. Wir möchten sicherstellen, dass
wir all das abdecken. Das könnte also eine
Hausaufgabe sein, wenn du, äh,
du weißt schon, erforschen und implementieren
und dann einen 100-prozentigen Unit-Test machen willst. Ich denke,
das wäre eine
großartige Gelegenheit dafür und bestätige auch, dass
das Alter, das älter als 80 ist, eine weitere
Sache ist, die Sie
tun und hoffentlich
100% erreichen könnten tun und hoffentlich
100% erreichen , wenn Sie
das wünschen. Der wahre Wert liegt
also, wissen Sie, wie ich bereits erwähnt habe,
darin, Ihre
Geschäftsregeln zu validieren, oder? Wir haben
eine Anwendung implementiert, eine sehr einfache Anwendung die keinen
Zugriff auf die Datenbank hat,
aber wir haben
Datenbankoperationen und Einfügungen simuliert Wir haben unsere Geschäftsregeln für die
Sozialversicherungsnummer
implementiert und konnten die
meisten unserer Geschäftsregeln validieren . Wir haben die meisten
unserer Geschäftsregeln validiert. Das gibt, wissen Sie, Softwareingenieuren
mehr Sicherheit. Es gibt uns, wissen Sie, Möglichkeit, Änderungen vorzunehmen, oder die
Sicherheit, Änderungen vorzunehmen, oder? Wir können Änderungen vornehmen
und gewissermaßen
garantieren, dass unsere
Geschäftsregeln und
unsere Logik eingehalten werden, wenn Sie das Refactoring
durchführen, wenn Sie Ihre
Codebasis aktualisieren und Änderungen vornehmen Dies ist eine sehr
einfache Anwendung, aber Unit-Tests
sind klein, oder? Wenn Sie also in
die reale Welt kommen, schreiben
Sie immer noch
kleine Methoden. Du schreibst immer noch, weißt du, du
überprüfst immer noch deine Logik Obwohl das
einfach ist, ist es sehr gut auf
reale Szenarien
anwendbar Ich hoffe, dass Ihnen diese Analyse
der Codeabdeckung, Implementierung des Komponententests und die
Überprüfung der Anforderungen Augen über den
Wert von Komponententests
öffnen. Das Ziel hier ist, ähm,
sicherzustellen, dass Sie als
Softwareentwickler den Wert
von Komponententests
verstehen, den Wert
von Komponententests
verstehen, wie sie Ihnen helfen können,
sich als Entwickler weiterzuentwickeln,
Ihnen helfen, Ihre
Codebasis weiterzuentwickeln, oder? Schreiben Sie besseren Code, schreiben Sie kleinere, präzise Methoden und
validieren Sie diese Methoden, validieren Sie Ihre Regeln
so,
dass
Sie eine Software entwickeln können , die weiterentwickelt bis
hin zu einer besseren
Architektur oder zur Erfüllung Geschäftsanforderungen oder des Ziels Ihres Produkts
22. Schlussbemerkung zum Kurs: Hallo, da. Willkommen zum Abschluss
des Kurses. Zuallererst möchte
ich Ihnen, wenn Sie
sich dieses Video ansehen, dazu gratulieren, dass
Sie so weit gekommen sind. Ich würde sagen, dass 90% der
Fachkräfte nicht
die Zeit investieren , die sie könnten
oder zumindest nicht, in das Lernen investieren, und Sie gehören zu den 10%. Index In diesem Abschnitt werden
wir auf die wichtigsten Themen eingehen, die während des Kurses
vermittelt wurden. Lassen Sie uns also einen Überblick geben. Zuerst haben wir die Grundlagen des
Softwaretests besprochen. Wir haben darüber gesprochen, warum
Softwaretests wichtig sind, wie zum Beispiel die Kosten von
Fehlern, einige Ausreden, Ausreden
zum Testen und auch die
Prinzipien des Wir haben die Definition von Komponententests besprochen und dabei über
Vor- und Nachteile gesprochen und darüber , wie
wir Komponententests effektiv durchführen Wir haben auch über
Integrationstests gesprochen, bei
denen wir uns eine
Testbilanz angesehen haben, um Unit-Tests mit
Integrationstests zu
vergleichen. Und dann sind wir zu zehn Tests
übergegangen, wo wir uns auch mit
den Vor- und Nachteilen befasst haben und wann zehn Tests
am häufigsten verwendet werden. Schließlich haben wir uns eine
Testpyramide angesehen in der
wir die Integration von Einheiten
und Endtests miteinander vergleichen, und wir hatten ein Bild, in dem wir Realität und Komplexität
anhand der Art des Tests
überprüften . Als Nächstes haben wir uns einen Anwendungsfall angesehen. Wir haben uns das
Caesar-Stipendium angesehen. Wir haben die Input- und
Output-Analyse mit ihren
grundlegenden Anforderungen analysiert Output-Analyse mit ihren
grundlegenden Anforderungen Wir haben dann veröffentlicht, oder? Wir haben uns Gedanken darüber wie diese Anwendung veröffentlicht werden
würde. Und dann gingen wir die
ersten Schritte der Unit-Tests durch,
wie zum Beispiel das Testen der
Preisberechnungen. Schließlich haben wir
über das
Testen von Einheiten mit der Xit-Bibliothek gesprochen . Wir haben besprochen, warum
diese Bibliothek so
wichtig ist und warum
wir uns dafür entschieden haben, sie zu verwenden. Anschließend haben wir über
die Testprojektebene
in Visual Studio gesprochen . Wir haben mit dem
Test Explorer gearbeitet, in dem wir Komponententests auf der Grundlage des
aktuellen Zustands oder der
voreingestellten Bedingungen ausgeführt haben . Anschließend arbeiteten wir an Formatierungen oder Tests, bei denen wir
die Faktenattribute,
die theoretischen Attribute,
das AA-Muster
und einige
Namenskonventionen für Tests analysierten die theoretischen Attribute,
das AA-Muster . Anschließend haben wir mit
Assertions und
Fluent Assertions weitergemacht Assertions und
Fluent Assertions Typen
wie Boolesche Werte,
Ausnahmen, Numerik und andere Typen getestet Ausnahmen, Numerik Aus Gründen der besseren Lesbarkeit haben wir uns Fluent Assertions angesehen. Anschließend haben wir uns mit der Codeabdeckung und ihren Anschließend haben wir über die Anforderungen
für Softwaretests gesprochen. Die Anforderungen basierten auf dem Geburtsdatum und der
Sozialversicherungsnummer. Wir haben eine Benutzerentität, Benutzerdaten und
eine Implementierung der
Sozialversicherungsnummernklasse erstellt . Dann wurde uns klar, dass
wir Daten simulieren mussten, also nutzten wir dafür die
MQ-Bibliothek Wir verwenden auch Bibliotheken wie Automc, um Mocking zu erleichtern,
und dann haben wir
Mocking mit unserem Datenzugriff implementiert Anschließend haben wir
die Einheitstests für
das Alter in den
Sozialversicherungsklassen eingeführt das Alter in den
Sozialversicherungsklassen Und schließlich
haben wir
auf der Grundlage
des von uns
geschriebenen Codes eine Analyse der Codeabdeckung durchgeführt. Das war also eine Menge. Ich möchte mich bei Ihnen dafür bedanken, dass Sie
sich diesen Kurs angesehen haben. Ich hoffe, dass
Ihnen dies hilft,
die Bedeutung von Tests
und Anwendungen zu verstehen , und dass es Ihnen hilft, sich
als Softwareingenieur weiterzuentwickeln. Denken Sie daran, bis zum nächsten Mal weiter zu lernen
und sich weiterzuentwickeln.