Ich bin Student und arbeite an meinem BE (CS). Meine Frage lautet wie folgt:

1. Sind Tests im Softwarebereich erforderlich?
2. Wenn wir eine Software mit größter Sorgfalt erstellen, warum sollten wir dann testen?
3. Können wir nach dem Testen sicher sein , dass wir dieses Ziel erreicht haben (das Produkt / die Software funktioniert wie beabsichtigt), weil wir die Tests dafür durchgeführt haben? Ist es möglich?

Meine Frage: Wird das Testen von Software benötigt ?

Ja. Denn egal wie gut du bist, du kannst nicht an alles denken.

• Sie werden auch gebeten, Ihre Software dazu zu bringen, Dinge zu tun, die Sie nie beabsichtigt haben.
• Sie werden auch niemals Anforderungen haben, die so klar sind, dass Sie über jede Möglichkeit nachdenken können, um sicherzustellen, dass der Code nicht kaputt geht.
• Sie werden auch mit Software und APIs anderer Leute arbeiten, die nicht immer wie beabsichtigt funktionieren, aber Sie werden davon ausgehen, dass dies zu Fehlern in Ihrem "perfekten" Fall führt oder führen sollte.

Ja

Aus dem gleichen Grund, dass ein Koch sein Essen schmeckt, während er es kocht.

Ich arbeite mit jemandem, der so denkt, er denkt, dass er seinen Code nicht mehr testen muss, weil er ein erfahrener Programmierer ist. Das Unternehmen weiß nicht, wie gefährlich diese Einstellung ist, und statt ihn sofort zu entlassen, haben sie mehr Programmierer eingestellt, um den Fehlerrückstand zu beheben. Da sie nicht wissen, woher dieser Rückstand stammt, denken sie, er ist Teil dessen, worum es beim Programmieren geht. Grundsätzlich haben wir 3 Programmierer, die in diesem Modus arbeiten, und ein Team von 20, die nichts anderes tun, als die Fehler, die diese drei verursachen, zu testen und zu beheben.

FEHLT DIE RICHTIGEN TESTEN KILLS .

Wenn Sie also nicht GOTT sind oder irgendeine Version eines vollkommenen allwissenden Wesens (das würde ich gerne sehen) oder wenn Sie nicht aktiv und schnell gefeuert werden möchten, empfehle ich Ihnen dringend, mit dem Testen zu beginnen.

Software wird von Menschen geschrieben.

Die Leute sind unvollkommen und machen Fehler.

Mit zunehmender Komplexität eines Unternehmens steigt die potenzielle Anzahl (und Auswirkung) von Fehlern, Versehen oder Vergessenen - in der Regel exponentiell.

Also ja, Tests sind erforderlich. Es bringt Balance und Perspektive.

Steigen Sie in einen Flug mit einem Betriebssystem ein, von dem Sie wissen, dass Sie es auf Ihrem Laptop verwendet haben und das Ihnen einen Todesbildschirm in Ihrer Lieblingsfarbe beschert hat? Denk darüber nach.

Kein Programmierer ist perfekt. Weit, weit, weit davon entfernt. Sie müssen testen, und Tester bringen häufig Perspektiven (auch als Anwendungsfälle bezeichnet) ein, die den Entwicklern fehlten.

Suchen Sie bei Google nach den bekanntesten Software-Fehlern, um zu erfahren, was ich meine.

Lesen Sie auf College-Ebene etwas über testgetriebene Entwicklung, Unit-Tests und agile Praktiken, um zu erfahren, wo sich die Dinge gerade befinden.

Das Testen ist ein absolutes Muss für jede nicht triviale (in Größe oder Funktion) Anwendung, die tatsächlich verwendet werden soll. Sie werden keinen einzigen Entwickler finden, der sich um sein Handwerk kümmert (wie durch den Besuch dieser Website belegt), der antwortet und angibt, dass keine Tests erforderlich sind.

Zusätzlich zu den bereits veröffentlichten Informationen können Sie durch eine vollständige Suite automatisierter Komponententests für eine bestimmte Anwendung sicherer auf zukünftige Codeänderungen reagieren. Diese höhere Zuverlässigkeit (da Unit-Tests ein BIG-Sicherheitsnetz bieten) führt zu schnelleren Codeänderungen an vorhandenen Anwendungen (aufgrund weniger Backtracking / Double Checking).

Errare humanum est

Es gibt keine fehlerfreie Software.

Der erfahrenste Entwickler schreibt Code mit Fehlern. Selbst wenn ein perfekter Entwickler existieren würde, gäbe es immer noch Fehler aufgrund von Unstimmigkeiten zwischen:

• Benutzeranforderungen und Spezifikationsdokumente
• Spezifikation und Design
• erwartete und tatsächliche Hardware- und Software-Umgebungen
• gestern und heute wahrheit: alles, was oben aufgeführt ist, unterliegt änderungen, über die nicht in jedem schritt des entwicklungsprozesses perfekt berichtet wird.

Der perfekte Entwickler ist nur ein Teil des Ganzen. Und perfekte Entwickler gibt es nicht.

Die meisten realen Programme:

a) Hunderte oder mehr Codezeilen enthalten, die auf mehrere Dateien verteilt sind;
b) von mehr als einem Programmierer entwickelt wurden;
c) in Umgebungen verwendet werden, die sich von der Umgebung des Entwicklers unterscheiden

Wenn Sie also nicht überprüfen, wie das Programm in der Praxis funktioniert, liegt die Wahrscheinlichkeit, dass es überhaupt nicht funktioniert, nahe bei 100%.

Denken Sie neben all den anderen tollen Antworten auch an die anderen Programmierer, die sich in Zukunft mit Ihrem Code befassen müssen, selbst wenn Sie wissen, dass er perfekt und fehlerfrei ist. Sie wissen es nicht so wie Sie und möchten sich auf Ihre Tests verlassen, um sicherzustellen, dass sie nach einer Änderung nichts kaputt gemacht haben. Dies gilt natürlich auch für Sie selbst, nachdem Sie Ihren Code seit einem Jahr nicht mehr gesehen haben!

JA.

Hier ist eine weitere etwas subtilere Perspektive, die noch nicht ganz behandelt wurde:

Unterschätzen Sie niemals die Notwendigkeit einer "unabhängigen Verifizierung" . Aus dem gleichen Grund ist es gut, ein paar unabhängige Redakteure über Ihre Arbeit zu informieren, bevor Sie eine große Schrift zur Veröffentlichung einreichen. Egal wie gut Sie als Schriftsteller sind, Sie werden gelegentlich Brainfart machen - und etwas wie "in" anstelle von "es" schreiben oder so. Wenn Sie es selbst noch einmal sorgfältig durchlesen, werden Sie es in der Regel immer noch vermissen, da Ihr Gehirn Ihren Gedankenfluss automatisch als korrekt akzeptiert und den Fehler überschlägt. Für ein frisches Paar von Augen ist diese Art von Fehler normalerweise ziemlich grell.

Das Gleiche gilt für die Programmierung: Es ist ziemlich einfach, in einen Ablauf zu gelangen, in dem entweder Ihr Code oder Ihre grundlegenden "Entwicklungstests" Ihres eigenen Codes korrekt aussehen, weil Sie ihn testen und auf eine bestimmte Weise verwenden. Aber wenn ein weiteres Paar Hände vorbeikommt und die Dinge auf eine etwas andere Weise oder in einer anderen Reihenfolge anklickt, stürzt alles ab.

Natürlich könnten Sie theoretisch den Weg gehen, jede einzelne Möglichkeit und jeden logischen Zweig in Ihrem Code selbst zu überprüfen, aber für nicht-triviale Software ist dies weitaus teurer und zeitaufwändiger, als wenn jemand anderes auf die Probe gestellt wird Code für Sie. Und Sie werden wahrscheinlich immer noch Dinge vermissen, an die Sie nie gedacht haben.

Was noch nicht angerührt wurde: Auch wenn Ihr Code perfekt ist, sind Sie immer noch nicht sicher. Compiler haben Fehler, die dazu führen können, dass sich selbst perfekter Code nach dem Kompilieren nicht mehr richtig verhält. Betriebssysteme haben Fehler, die dazu führen können, dass sich eine perfekte Binärdatei beim Ausführen falsch verhält. Hardware hat Fehler, die Probleme verursachen können.

Das ist auch der Grund, warum das Testen auf einer Maschine für kommerzielle Produkte nicht ausreicht. Sie müssen unter so vielen möglichen Kombinationen von Hardware und Software getestet werden, wie dies in der Natur möglich ist.

Der Leiter des Teams, das die Software für das Space Shuttle schrieb, flog vor jedem Start heraus, um zu signalisieren, dass die Software dem Shuttle keinen Schaden zufügen würde.

Was gab ihm Ihrer Meinung nach das Vertrauen dazu?

Sie testen ständig Code, indem Sie ihn kompilieren und verwenden. In einigen IDEs werden Sie während der Eingabe auf Fehler überprüft. Sofern Sie Ihren Code nicht tatsächlich ausführen, führen Sie Tests durch.

Wie viel Sie testen, ist wirklich die Wurzel dieser Art von Frage, und die Antwort darauf hängt vom Risiko ab. Sie testen so viel, wie es sinnvoll ist, aus Sicht des Risikomanagements zu testen. Es ist normalerweise unmöglich, alles oder nichts zu testen. Nahezu nichts zu testen ist normalerweise ein schlechter Schachzug. Alles dazwischen ist faires Spiel, abhängig von der Risikostufe und der Gefährdung Ihres Ergebnisses.

Riecht nach einer Hausaufgabe.

Sind Tests im Softwarebereich erforderlich?

Ja. Absolut. Auf allen Ebenen. Außerhalb einiger spezialisierter Domänen sind wir noch nicht in der Lage, mathematisch zu beweisen, dass unser Code gegen bestimmte Bugs korrekt ist (zumindest nicht in einem angemessenen Zeitrahmen). Wir müssen also Steine ​​darauf werfen, um zu sehen, ob und wo es bricht.

Wenn wir eine Software mit größter Sorgfalt erstellen, warum sollten wir dann testen?

Beim Testen geht es nicht nur darum, Codierungsfehler zu finden. Es geht auch darum, sicherzustellen, dass Sie alle Ihre Anforderungen erfüllt haben und dass das Gesamtsystem wie erwartet funktioniert. Wenn ich die Anforderung habe, dass eine fehlgeschlagene Transaktion einen bestimmten Fehlercode zurückgeben muss, muss ich einen Test schreiben, um zu überprüfen, ob die Funktionalität vorhanden ist und ordnungsgemäß funktioniert.

Und das alles setzt voraus, dass die Spezifikation und das Design vollständig, korrekt und in sich konsistent sind, was häufig nicht der Fall ist. Selbst wenn Sie die Spezifikation bis zum letzten Punkt und Semikolon einhalten und dem Design folgen, kann es bei schlechten Spezifikationen oder Designs zu Problemen bei der Integration kommen. Häufig werden System- oder Integrationstests durchgeführt, wenn Sie feststellen, dass die Spezifikation selbst fehlerhaft ist und überarbeitet werden muss (siehe Kriegsbericht unten).

Können wir nach dem Testen sicher sein, dass wir dieses Ziel erreicht haben (das Produkt / die Software funktioniert wie beabsichtigt), weil wir die Tests dafür durchgeführt haben? Ist es möglich?

Nein, nicht zu 100%. Wir können nicht jede nur denkbare Kombination von Eingaben oder Ausführungspfaden in dem einfachsten Code testen. Wir können nicht alle Umweltfaktoren berücksichtigen. Wir können uns nicht alle möglichen Fehlermodi vorstellen.

Wir können bis zu einem Punkt testen, an dem wir ziemlich sicher sind, dass es keine großen Probleme gibt. Auch dies ist der Grund, warum wir auf allen Ebenen testen müssen. Schreiben Sie eine Reihe von Tests, um sicherzustellen, dass Ihr Code die Randbedingungen richtig verarbeitet (fehlerhafte Eingaben, unerwartete Ergebnisse, Ausnahmen usw.). Komponententest, um zu überprüfen, ob Ihr Code den Anforderungen entspricht. Systemtest zur Verifizierung der End-to-End-Verarbeitung. Integrationstest, um sicherzustellen, dass alle Komponenten korrekt miteinander kommunizieren. Machen Sie Usability-Tests, um sicherzustellen, dass das Ganze so funktioniert, dass Kunden Sie nicht erschießen möchten.

Szenario in der Realität - Ich arbeitete an einem Back-End-System, das gelegentlich Aktualisierungen an einen GUI-Dienst zur Anzeige in einer Tabelle auf dem Bildschirm sendete. Während des Projekts wurde eine Anforderung hinzugefügt, um die Anzeige zu filtern (z. B. kann der Bediener eine Teilmenge der Einträge in der Tabelle anzeigen). Designfehler Nr. 1 - Die Filterung sollte vom GUI-Dienst durchgeführt worden sein (ich bin der Meinung, dass die Display-Verwaltungsfunktionen in der Verantwortung der Display-Verwaltungssoftware liegen sollten), aber aufgrund der Politik und meiner Unfähigkeit, Probleme zu erkennen, bevor sie auftreten Probleme , wurde diese Anforderung an den Back-End-Service gestellt. Na gut, kein Problem, das kann ich. Wenn sich der Filterstatus ändert, erhalte ich eine Nachricht und sende dann eine Nachricht zum Erstellen oder Löschen fürjede Zeile in der Tabelle , da die Benutzeroberfläche so funktioniert (Designfehler Nr. 2 - Es gibt keine Möglichkeit, Aktualisierungen an mehrere Zeilen in einer einzelnen Nachricht zu senden; wir konnten nicht einmal eine einzelne "clear" - oder "delete" -Nachricht senden, um sie zu löschen die gesamte Tabelle).

Nun, alles funktioniert gut während der Entwicklung; Unit-, System- und Integrationstests zeigen, dass ich die richtigen Informationen sende und die Filteränderungen korrekt behandle. Dann kommen wir zu Usability-Tests, und das Ganze fällt schwer , weil das Datenvolumen überwältigend war. Die Netzwerklatenz zwischen meinem Back-End-Service und der GUI lag in der Größenordnung von 0,15 bis 0,25 Sekunden. Nicht schlecht, wenn Sie nur etwa ein Dutzend Zeilen aktualisieren müssen. Tödlich, wenn Sie Updates für mehrere hundert senden müssen. Wir bekamen Fehlermeldungen, dass die Benutzeroberfläche nach dem Ändern des Filterstatus abstürzte. Nun, nein, was geschah war, dass es in der Größenordnung von mehreren Minuten dauerte zum Aktualisieren der Anzeige, da das Nachrichtenprotokoll "Aktualisieren einer Zeile nach dem anderen" kein realistisches Szenario verarbeiten konnte.

Beachten Sie, dass all dies von jedem vom Hauptauftragnehmer bis zu meinem kleinen Alter hätte erwartet werden können und sollten , wenn wir uns die Mühe gemacht hätten, im Voraus die grundlegendsten Analysen durchzuführen. Die einzige Verteidigung, die ich anbieten werde, ist, dass wir das zweite Jahr eines sechsmonatigen Projekts abschließen, das fast unmittelbar nach der Auslieferung ausrangiert werden sollte, und wir alle wollten unbedingt den Hintergrund sehen.

Das bringt uns zum letzten Testgrund - CYA. Projekte der realen Welt scheitern aus einer Vielzahl von Gründen, von denen viele politisch sind, und nicht jeder handelt in gutem Glauben, wenn etwas schief geht. Finger zeigen, Anschuldigungen werden erhoben, und am Ende des Tages müssen Sie auf eine Aufzeichnung verweisen können, die zeigt, dass zumindest Ihr Zeug so funktioniert hat, wie es sollte.

Tests werden immer durchgeführt und Fehler werden immer gefunden. Es ist nur so, dass entweder die Tests intern von Ihrem Team durchgeführt werden oder der Endbenutzer der Tester ist. Die Kosten für einen vom Endbenutzer gefundenen Fehler sind erheblich höher als bei Tests.

Ich würde vorschlagen, einen guten Fault-Tolerant-Computing-Kurs zu belegen. Sorgfältiges Design von Software ist nur eine der Säulen für die Robustheit Ihres Softwareprodukts. Die anderen beiden Säulen sind ausreichend Test und redundantes Design. Die grundlegende Absicht besteht darin, eine exponentielle Anzahl unbekannter Fehlerzustände zu berücksichtigen und den Umgang mit einigen der bekannten zu priorisieren:

1.) möglichst viele mögliche Fehler durch Design und ordnungsgemäße Implementierung beseitigen 2.) unvorhergesehene Fehler in der Designphase und falsche Implementierung durch verschiedene Testformen (Einheit, Integration, Zufall) beseitigen 3.) verbleibende Fehler durch Redundanz beseitigen ( zeitlich => neu berechnen, wiederholen oder räumlich => Kopien behalten, Parität)

Wenn Sie die Testphase eliminieren, haben Sie nur noch Entwurfs- und Redundanzphasen für die Behebung von Fehlern.

Auch aus Produktsicht werden Ihre Stakeholder (z. B. Management, Benutzer, Investoren) die Zusicherung wünschen, dass Ihr Produkt bestimmte Qualitäts- und Sicherheitsspezifikationen, Kriterien usw. erfüllt. Haben Sie die Software darüber hinaus nicht getestet? Sie haben nur gebaut, um einen 'Sanity Check' durchzuführen? All diese Gründe machen Softwaretests zwingender.

Alle Programme haben, zumindest zu Beginn, Fehler.

Es gab einige Studien, die auf etwa 1 Fehler pro fünf Zeilen ungetesteten Codes konvergieren.

Eine Geschichtsstunde:

In den 1960er Jahren benötigte IBM ein "NOP" -Programm, um einige Funktionen in JCL ausführen zu können, ohne ein Programm auszuführen. Die Entwickler entwickelten ein einzeiliges Assembler-Programm, in dem der gesamte Code unter dem Namen "IEFBR14" enthalten war. Der eigentliche Code war:

       BR 14 * brach to return address in register 14

Während seiner langen Laufzeit wurden für dieses einzeilige Programm zwei Fehlerberichte und fünf Änderungen vorgenommen.

Code-Refactoring geht bei Unit-Tests sehr viel schneller. Ein Unit-Test zeigt Ihnen auch die einfache Verwendung konkreter Funktionen, sodass Sie ein kleines "Howto" haben, das in großen Projekten nützlich sein kann, in denen Programmierer nicht genau den gesamten Code kennen.

Wenn Sie mit TDD (Test Driven Development) entwickeln, haben Sie keine unnötigen Getter / Setter usw. Sie erstellen nur das, was Sie brauchen.

Um # 3 Ihrer Frage zu beantworten :

Als Programmierer und Software-Tester können Sie sicher sein, dass Sie die Anforderungen der Software beim Testen erfüllen.

{QA Hut aufsetzen}

Wie? Sie können dies tun, indem Sie Ihre Tests vom Testcode bis zu Akzeptanzkriterien, Akzeptanzkriterien bis zu Features und Features bis zu Anforderungen verfolgen. Wenn Sie jeden einzelnen Test in der Entwurfskette nachverfolgen und diese einer oder mehreren Anforderungen zuordnen, können Sie sicher sein, dass Ihre Tests verwendet werden, um sicherzustellen, dass der Code den Anforderungen entspricht (obwohl dies den Gedanken einer angemessenen Testabdeckung aufwirft, was a ein anderes Thema). Wenn Sie einen Test in der Entwurfskette nicht nachvollziehen können, testen Sie wahrscheinlich auf Dinge, die nicht erforderlich sind, und dies ist Zeitverschwendung. Zu den Akzeptanzkriterien kann auch die Überprüfung auf unerwünschte Verhaltensweisen gehören. Sie können diese auch testen, um einer Qualitätsfreigabe einen Schritt näher zu kommen.

{QA Hut ab}

Kein Code ist jemals fehlerfrei und im Laufe der Zeit weniger kostspielig, wenn mehr Aufwand für die Bewertung der Qualität während der Entwicklung aufgewendet wird.

Ich bin jetzt seit 3 ​​Jahren ein Software-Tester. Anfangs war ich selbst skeptisch, was Tests angeht, da ich dachte, wenn die Entwicklungsabteilung und das Projektmanagement ihre Arbeit machen, sollten keine Fehler in der Software auftreten.

ABER das ist nicht der Fall. ++++++++

Fehler treten häufig auf, von denen einige für den Betrieb eines Projekts von entscheidender Bedeutung sind. Es gibt auch Cross-Browser-Tests (dh Tests mit verschiedenen vorhandenen Browsern wie SAFARI, FIREFOX, CHROME und Internet Explorer) und ich habe an einem Projekt gearbeitet, bei dem einfache Schaltflächen wie JA und NEIN in einem Umfragefenster nicht in allen Browsern funktionieren manche von ihnen.

Ich habe beim Testen von Internetseiten mitgearbeitet und einfache TEXTÄNDERUNGEN getestet. Ich dachte mir, dass diese einfache Arbeit auf keinen Fall fehlerhaft sein kann, aber es passiert nichts.

Ich habe auch gesehen, dass neue Entwickler dem Team beitreten und ein Update-Workpiece für ein vorhandenes komplexes Internetanwendungsformular mit einer Reihe von Verknüpfungen / Aufrufen zu externen Seiten erhalten. Ein Fehler trat auf, weil die Kommunikation zwischen alten und neuen Entwicklern fehlte. aus verschiedenen Gründen (keine Zeit zum Aufklären, kein Wille zum Aufklären und so weiter).

JA

Stellen Sie sich vor, Ihre Software ist nur eine logische Funktion UND (b1, b2), wobei b1 und b2 nur Bits sind. Damit benötigen Sie 4 Testfälle, um sicherzustellen, dass Ihre Software fehlerfrei ist, wenn Ihre Umgebung genau das liefert, wofür sie spezifiziert wurde.

Jetzt besteht Ihr System aus vielen Funktionen, deren einfachste viel komplizierter ist als diese logische Funktion. Wie würden Sie sicherstellen, dass es fehlerfrei ist?

(Fortsetzung folgt)